{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# COMPSCI 389: Introduction to Machine Learning\n",
"# Generative AI\n",
"\n",
"Generative AI techniques are methods for generating new content like text, images, music, or other data, often mimicking some aspects of human creativity.\n",
"\n",
"Unlike supervised learning, which involves learning from *labeled* data, generative AI aims to learn the underlying patters, features, and distributions of a dataset so that it can generate new, similar data. Hence, it is a form of *unsupervised* learning. \n",
"\n",
"Two core methods in generative AI are **variational autoencoders** (VAEs) and **generative adversarial networks** (GANs). In this notebook we review VAEs and GANs. We then provide an overview of how **large language models** (LLMs) are trained."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Variational Autoencoders (VAEs)\n",
"\n",
"VAEs are trained from a data set like a set of images. They learn to create new rows (data points) that resemble those in the provided data set. They do this by converting this unsupervised learning problem into a supervised learning problem, and then applying the methods that we have discussed (gradient descent on a loss function for a parametric model).\n",
"\n",
"Specifically, VAEs take an input, $X_i$, and try to output $X_i$. That is, their loss function measures how close the output is to the input, $X_i$. Such a loss function is called a **reconstruction loss**. For image data, the *mean squared error* (MSE) between the pixel values of the original and reconstructed images is one common choice.\n",
"\n",
"This may seem simple: just define a parametric model that maps the input to the output! The key insight in VAEs is that the parametric model can be deliberately constructed to force the model to do more than this. The diagram below depicts a common *artificial neural network* (ANN) architecture for a VAE:\n",
"\n",
"\n",
"\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"The smaller boxes in the middle represent layers with fewer units. In order to reconstruct the input, $x$, with this architecture, the network must learn a smaller representation that incodes the content of the image. This smaller representation is called an **embedding** or a **latent representation**. This figure writes **latent space** to denote the space of all vectors that can be represented by the middle layer.\n",
"\n",
"As an exmaple, consider the problem of reconstructing images of cats. The input might be a large high-resolution RGB image. Even at a resolution of 1024x768 (with three channels, R,G, and B), an image is represented as 2,359,296 numbers. If the latent space is represented by a layer with 100 units, the network must learn to represent the entire image (2,359,296 numbers) with just 100 numbers! To do this, it might learn features like the breed of the cat (to determine the color), the age of the cat, the angle of the cat, whether the background is indoors or outdoors, etc.\n",
"\n",
"Intuitively, the \"Encoder\" part of the network (the part of the network before the bottleneck of a small layer that is the latent space) will learn to map an image into the latent space (into the smaller representation describing the image). The \"Decoder\" part of the network (the part of the network after the bottleneck) will then learn to map this latent representation back to an image.\n",
"\n",
"Note that none of this behavior is hard-coded into the methods. The network is simply designed to have a small layer in the middle, and then trained to minimize the reconstruction loss. The network then creates an encoder and decoder on its own!\n",
"\n",
"Once an encoder and decoder have been trained, you can generate new images by providing random vectors as input to the decoder, essentially \"making up\" the representation is latent space and asking the decoder to reconstruct the image.\n",
"\n",
"However, without additional mechanisms, the autoencoder may learn to only use certain values in the latent space, and so new random vectors in the latent space may not map to meaningful images. **Variational** autoencoders modify the reconstruction loss function to also encourage the network to make the latent representation have a Gaussian distribution. This way, new outputs can be generated by sampling vectors of Gaussian noise and treating them as the latent representation to be decoded. The details of this process is beyond the scope of this class, but note that one common reconstruction loss for autoencoders is called the **evidence lower bound** or (ELBO). This is simply a loss function that balances A) ensuring that the distribution of latent representations that results from the training data is roughly Gaussian, with B) the objective of reconstructing the output."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Example VAE\n",
"\n",
"Although the details are beyond the scope of this course, notice that training a VAE in PyTorch is not significantly different from the classification and regression examples we have seen. The main difference is that the forwards pass doesn't just output the attempted reconstruction of the image: it also outputs information related to the latent representation of the image. This is necessary for the loss function to push the network towards a latent representation of the input data that is Gaussian."
]
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [],
"source": [
"import torch\n",
"import torchvision\n",
"from torch import nn, optim\n",
"from torchvision import transforms\n",
"from torch.nn import functional as F\n",
"import matplotlib.pyplot as plt\n",
"import numpy as np"
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {},
"outputs": [],
"source": [
"# VAE model\n",
"class VAE(nn.Module):\n",
" def __init__(self):\n",
" super(VAE, self).__init__() # Call the nn.Module initializer\n",
" self.fc1 = nn.Linear(784, 400)\n",
" self.fc21 = nn.Linear(400, 20) # mu layer (mean of the Gaussian)\n",
" self.fc22 = nn.Linear(400, 20) # logvar layer (log of the variance)\n",
" self.fc3 = nn.Linear(20, 400)\n",
" self.fc4 = nn.Linear(400, 784)\n",
"\n",
" def encode(self, x):\n",
" h1 = F.relu(self.fc1(x))\n",
" return self.fc21(h1), self.fc22(h1)\n",
"\n",
" def reparameterize(self, mu, logvar):\n",
" std = torch.exp(0.5*logvar)\n",
" eps = torch.randn_like(std) # The length is that of \"std\", but these are samples of N(0,1)\n",
" return mu + eps*std\n",
"\n",
" def decode(self, z):\n",
" h3 = F.relu(self.fc3(z))\n",
" return torch.sigmoid(self.fc4(h3))\n",
"\n",
" def forward(self, x):\n",
" mu, logvar = self.encode(x.view(-1, 784))\n",
" z = self.reparameterize(mu, logvar)\n",
" return self.decode(z), mu, logvar"
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {},
"outputs": [],
"source": [
"# Loss function (ELBO)\n",
"def loss_function(recon_x, x, mu, logvar):\n",
" BCE = F.binary_cross_entropy(recon_x, x.view(-1, 784), reduction='sum')\n",
" KLD = -0.5 * torch.sum(1 + logvar - mu.pow(2) - logvar.exp())\n",
" return BCE + KLD"
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Downloading http://yann.lecun.com/exdb/mnist/train-images-idx3-ubyte.gz\n",
"Failed to download (trying next):\n",
"HTTP Error 404: Not Found\n",
"\n",
"Downloading https://ossci-datasets.s3.amazonaws.com/mnist/train-images-idx3-ubyte.gz\n",
"Downloading https://ossci-datasets.s3.amazonaws.com/mnist/train-images-idx3-ubyte.gz to ./data\\MNIST\\raw\\train-images-idx3-ubyte.gz\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"100%|██████████| 9912422/9912422 [00:00<00:00, 51984454.62it/s]\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"Extracting ./data\\MNIST\\raw\\train-images-idx3-ubyte.gz to ./data\\MNIST\\raw\n",
"\n",
"Downloading http://yann.lecun.com/exdb/mnist/train-labels-idx1-ubyte.gz\n",
"Failed to download (trying next):\n",
"HTTP Error 404: Not Found\n",
"\n",
"Downloading https://ossci-datasets.s3.amazonaws.com/mnist/train-labels-idx1-ubyte.gz\n",
"Downloading https://ossci-datasets.s3.amazonaws.com/mnist/train-labels-idx1-ubyte.gz to ./data\\MNIST\\raw\\train-labels-idx1-ubyte.gz\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"100%|██████████| 28881/28881 [00:00<00:00, 1806593.30it/s]\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"Extracting ./data\\MNIST\\raw\\train-labels-idx1-ubyte.gz to ./data\\MNIST\\raw\n",
"\n",
"Downloading http://yann.lecun.com/exdb/mnist/t10k-images-idx3-ubyte.gz\n",
"Failed to download (trying next):\n",
"HTTP Error 404: Not Found\n",
"\n",
"Downloading https://ossci-datasets.s3.amazonaws.com/mnist/t10k-images-idx3-ubyte.gz\n",
"Downloading https://ossci-datasets.s3.amazonaws.com/mnist/t10k-images-idx3-ubyte.gz to ./data\\MNIST\\raw\\t10k-images-idx3-ubyte.gz\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"100%|██████████| 1648877/1648877 [00:00<00:00, 16074085.58it/s]\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"Extracting ./data\\MNIST\\raw\\t10k-images-idx3-ubyte.gz to ./data\\MNIST\\raw\n",
"\n",
"Downloading http://yann.lecun.com/exdb/mnist/t10k-labels-idx1-ubyte.gz\n",
"Failed to download (trying next):\n",
"HTTP Error 404: Not Found\n",
"\n",
"Downloading https://ossci-datasets.s3.amazonaws.com/mnist/t10k-labels-idx1-ubyte.gz\n",
"Downloading https://ossci-datasets.s3.amazonaws.com/mnist/t10k-labels-idx1-ubyte.gz to ./data\\MNIST\\raw\\t10k-labels-idx1-ubyte.gz\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"100%|██████████| 4542/4542 [00:00, ?it/s]"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"Extracting ./data\\MNIST\\raw\\t10k-labels-idx1-ubyte.gz to ./data\\MNIST\\raw\n",
"\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"\n"
]
}
],
"source": [
"# Data loading\n",
"transform = transforms.Compose([transforms.ToTensor()])\n",
"trainset = torchvision.datasets.MNIST(root='./data', train=True, download=True, transform=transform)\n",
"trainloader = torch.utils.data.DataLoader(trainset, batch_size=128, shuffle=True)"
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {},
"outputs": [],
"source": [
"# Model and optimizer\n",
"model = VAE()\n",
"optimizer = optim.Adam(model.parameters(), lr=1e-3)"
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Epoch 1, Loss: 163.6830\n",
"Epoch 2, Loss: 121.0160\n",
"Epoch 3, Loss: 114.4315\n",
"Epoch 4, Loss: 111.5428\n",
"Epoch 5, Loss: 109.8738\n",
"Epoch 6, Loss: 108.6868\n",
"Epoch 7, Loss: 107.8526\n",
"Epoch 8, Loss: 107.2281\n",
"Epoch 9, Loss: 106.6957\n",
"Epoch 10, Loss: 106.3061\n"
]
}
],
"source": [
"# Training\n",
"for epoch in range(1, 11):\n",
" train_loss = 0\n",
" for data, _ in trainloader:\n",
" recon_batch, mu, logvar = model.forward(data)\n",
" optimizer.zero_grad()\n",
" loss = loss_function(recon_batch, data, mu, logvar)\n",
" loss.backward()\n",
" train_loss += loss.item()\n",
" optimizer.step()\n",
" print(f'Epoch {epoch}, Loss: {train_loss / len(trainloader.dataset):.4f}')"
]
},
{
"cell_type": "code",
"execution_count": 7,
"metadata": {},
"outputs": [
{
"data": {
"image/png": "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",
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"# Generating images\n",
"def show_generated_images(model, num_images=10):\n",
" with torch.no_grad():\n",
" z = torch.randn(num_images, 20)\n",
" sample = model.decode(z).cpu()\n",
" sample = sample.view(num_images, 28, 28)\n",
"\n",
" fig, axs = plt.subplots(1, num_images, figsize=(num_images, 1))\n",
" for i in range(num_images):\n",
" axs[i].imshow(sample[i].numpy(), cmap='gray')\n",
" axs[i].axis('off')\n",
" plt.show()\n",
"\n",
"show_generated_images(model)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"After just 11 epochs (1.5 minutes on my CPU) of training, we're starting to see images that looks like hand-written letters! With more training these could likely be further improved."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Generative Adversarial Networks (GANs)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"GANs use two neural networks that learn from each other, competing in a king of tug-of-war. These two networks are called the **generator** and the **discriminator**.\n",
"\n",
"#### Generator\n",
"\n",
"The generator is tasked with creating fake data points (e.g., fake images). Its goal is to create images that are indistinguishable from the real ones in the data set. It starts by creating the image from random noise. That is, it takes random noise as input, and produces an image as output.\n",
"\n",
"#### Discriminator\n",
"\n",
"The discriminator takes both the fake images from the generator and the real images from the training data set as its input data (one image at a time). Its job is to learn to differentiate between the two, discerning real from fake.\n",
"\n",
"#### Training\n",
"\n",
"The loss function used by the generator penalizes it for producing images that the discriminator is able to detect as fakes. The loss function for the discriminator penalizes it fair failing to detect the generator's fakes.\n",
"\n",
"During the early stages of training, the generator's images are easily spotted as fakes. However, as training progresses, it starts to understand what makes an image more believable. It learns complex representations - not specific features like the color or shape of an object, but deeper aspects, like the way light and shadow play on surfaces or how different objects in an image relate to each other in space.\n",
"\n",
"What's truly remarkable is that this entire process evolves without explicit instructions on what to learn. The networks, through their adversarial training, figure out the details. Eventually, if the training is successful, the generator becomes so skilled that the discriminator can't tell its creations from real images.\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Example GAN"
]
},
{
"cell_type": "code",
"execution_count": 8,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Epoch [0/15], Step [100/938], d_loss: 0.1968, g_loss: 2.1253\n",
"Epoch [0/15], Step [200/938], d_loss: 0.1253, g_loss: 3.2851\n",
"Epoch [0/15], Step [300/938], d_loss: 0.1698, g_loss: 4.1563\n",
"Epoch [0/15], Step [400/938], d_loss: 0.0610, g_loss: 5.5070\n",
"Epoch [0/15], Step [500/938], d_loss: 0.0136, g_loss: 6.1925\n",
"Epoch [0/15], Step [600/938], d_loss: 0.0244, g_loss: 6.1424\n",
"Epoch [0/15], Step [700/938], d_loss: 0.0265, g_loss: 6.5670\n",
"Epoch [0/15], Step [800/938], d_loss: 0.0337, g_loss: 6.3879\n",
"Epoch [0/15], Step [900/938], d_loss: 0.0803, g_loss: 7.4044\n",
"Epoch [1/15], Step [100/938], d_loss: 0.1964, g_loss: 11.1679\n",
"Epoch [1/15], Step [200/938], d_loss: 0.1964, g_loss: 6.7413\n",
"Epoch [1/15], Step [300/938], d_loss: 0.1970, g_loss: 3.5620\n",
"Epoch [1/15], Step [400/938], d_loss: 0.2756, g_loss: 5.0921\n",
"Epoch [1/15], Step [500/938], d_loss: 0.3247, g_loss: 4.7702\n",
"Epoch [1/15], Step [600/938], d_loss: 0.3061, g_loss: 4.3312\n",
"Epoch [1/15], Step [700/938], d_loss: 0.2647, g_loss: 6.2605\n",
"Epoch [1/15], Step [800/938], d_loss: 0.3247, g_loss: 3.7898\n",
"Epoch [1/15], Step [900/938], d_loss: 0.5217, g_loss: 3.3301\n",
"Epoch [2/15], Step [100/938], d_loss: 0.2458, g_loss: 2.7131\n",
"Epoch [2/15], Step [200/938], d_loss: 0.4238, g_loss: 4.3987\n",
"Epoch [2/15], Step [300/938], d_loss: 0.5795, g_loss: 2.4602\n",
"Epoch [2/15], Step [400/938], d_loss: 0.5659, g_loss: 3.4101\n",
"Epoch [2/15], Step [500/938], d_loss: 0.4948, g_loss: 3.2021\n",
"Epoch [2/15], Step [600/938], d_loss: 0.4680, g_loss: 3.7562\n",
"Epoch [2/15], Step [700/938], d_loss: 0.6839, g_loss: 2.6689\n",
"Epoch [2/15], Step [800/938], d_loss: 0.8165, g_loss: 3.4143\n",
"Epoch [2/15], Step [900/938], d_loss: 0.4250, g_loss: 2.2062\n",
"Epoch [3/15], Step [100/938], d_loss: 0.5896, g_loss: 2.6581\n",
"Epoch [3/15], Step [200/938], d_loss: 0.4780, g_loss: 3.5904\n",
"Epoch [3/15], Step [300/938], d_loss: 0.6242, g_loss: 2.2625\n",
"Epoch [3/15], Step [400/938], d_loss: 0.6681, g_loss: 2.8004\n",
"Epoch [3/15], Step [500/938], d_loss: 0.7445, g_loss: 3.0726\n",
"Epoch [3/15], Step [600/938], d_loss: 0.5506, g_loss: 3.5891\n",
"Epoch [3/15], Step [700/938], d_loss: 0.7191, g_loss: 2.5736\n",
"Epoch [3/15], Step [800/938], d_loss: 0.7074, g_loss: 2.7978\n",
"Epoch [3/15], Step [900/938], d_loss: 0.5882, g_loss: 1.9058\n",
"Epoch [4/15], Step [100/938], d_loss: 0.9155, g_loss: 1.6220\n",
"Epoch [4/15], Step [200/938], d_loss: 0.6090, g_loss: 2.3546\n",
"Epoch [4/15], Step [300/938], d_loss: 0.7083, g_loss: 2.6362\n",
"Epoch [4/15], Step [400/938], d_loss: 0.8851, g_loss: 1.7231\n",
"Epoch [4/15], Step [500/938], d_loss: 0.7574, g_loss: 1.7395\n",
"Epoch [4/15], Step [600/938], d_loss: 0.8677, g_loss: 2.0268\n",
"Epoch [4/15], Step [700/938], d_loss: 0.6598, g_loss: 1.8621\n",
"Epoch [4/15], Step [800/938], d_loss: 0.6667, g_loss: 2.3757\n",
"Epoch [4/15], Step [900/938], d_loss: 0.5857, g_loss: 1.9318\n",
"Epoch [5/15], Step [100/938], d_loss: 0.6102, g_loss: 2.1001\n",
"Epoch [5/15], Step [200/938], d_loss: 0.7180, g_loss: 2.3402\n",
"Epoch [5/15], Step [300/938], d_loss: 0.6467, g_loss: 2.7362\n",
"Epoch [5/15], Step [400/938], d_loss: 0.8340, g_loss: 1.7500\n",
"Epoch [5/15], Step [500/938], d_loss: 0.6634, g_loss: 1.8997\n",
"Epoch [5/15], Step [600/938], d_loss: 0.8033, g_loss: 2.6520\n",
"Epoch [5/15], Step [700/938], d_loss: 0.9429, g_loss: 1.7822\n",
"Epoch [5/15], Step [800/938], d_loss: 0.8467, g_loss: 2.0240\n",
"Epoch [5/15], Step [900/938], d_loss: 0.6981, g_loss: 2.1250\n",
"Epoch [6/15], Step [100/938], d_loss: 0.9844, g_loss: 1.8475\n",
"Epoch [6/15], Step [200/938], d_loss: 0.7247, g_loss: 2.3818\n",
"Epoch [6/15], Step [300/938], d_loss: 0.7758, g_loss: 1.2705\n",
"Epoch [6/15], Step [400/938], d_loss: 0.6998, g_loss: 2.2222\n",
"Epoch [6/15], Step [500/938], d_loss: 0.9477, g_loss: 1.8426\n",
"Epoch [6/15], Step [600/938], d_loss: 0.6771, g_loss: 1.9632\n",
"Epoch [6/15], Step [700/938], d_loss: 0.9380, g_loss: 1.7148\n",
"Epoch [6/15], Step [800/938], d_loss: 0.6734, g_loss: 1.9416\n",
"Epoch [6/15], Step [900/938], d_loss: 0.8901, g_loss: 1.5339\n",
"Epoch [7/15], Step [100/938], d_loss: 0.9863, g_loss: 1.7283\n",
"Epoch [7/15], Step [200/938], d_loss: 0.7632, g_loss: 2.4689\n",
"Epoch [7/15], Step [300/938], d_loss: 0.9671, g_loss: 1.7843\n",
"Epoch [7/15], Step [400/938], d_loss: 0.7342, g_loss: 1.7388\n",
"Epoch [7/15], Step [500/938], d_loss: 0.7367, g_loss: 1.4516\n",
"Epoch [7/15], Step [600/938], d_loss: 0.9533, g_loss: 1.7038\n",
"Epoch [7/15], Step [700/938], d_loss: 0.9913, g_loss: 2.5165\n",
"Epoch [7/15], Step [800/938], d_loss: 0.6771, g_loss: 1.8887\n",
"Epoch [7/15], Step [900/938], d_loss: 0.8115, g_loss: 2.2673\n",
"Epoch [8/15], Step [100/938], d_loss: 0.8134, g_loss: 2.1915\n",
"Epoch [8/15], Step [200/938], d_loss: 0.7089, g_loss: 2.4003\n",
"Epoch [8/15], Step [300/938], d_loss: 0.9474, g_loss: 1.8414\n",
"Epoch [8/15], Step [400/938], d_loss: 0.9899, g_loss: 1.6218\n",
"Epoch [8/15], Step [500/938], d_loss: 0.8158, g_loss: 1.9243\n",
"Epoch [8/15], Step [600/938], d_loss: 0.7556, g_loss: 1.8116\n",
"Epoch [8/15], Step [700/938], d_loss: 0.7415, g_loss: 2.0091\n",
"Epoch [8/15], Step [800/938], d_loss: 0.6599, g_loss: 2.2918\n",
"Epoch [8/15], Step [900/938], d_loss: 0.8394, g_loss: 2.2152\n",
"Epoch [9/15], Step [100/938], d_loss: 0.8547, g_loss: 2.2970\n",
"Epoch [9/15], Step [200/938], d_loss: 0.9285, g_loss: 2.1147\n",
"Epoch [9/15], Step [300/938], d_loss: 0.9043, g_loss: 2.4567\n",
"Epoch [9/15], Step [400/938], d_loss: 1.0239, g_loss: 1.4896\n",
"Epoch [9/15], Step [500/938], d_loss: 0.7885, g_loss: 1.6315\n",
"Epoch [9/15], Step [600/938], d_loss: 0.6050, g_loss: 1.9700\n",
"Epoch [9/15], Step [700/938], d_loss: 0.7771, g_loss: 1.6589\n",
"Epoch [9/15], Step [800/938], d_loss: 0.7726, g_loss: 1.6334\n",
"Epoch [9/15], Step [900/938], d_loss: 0.9044, g_loss: 2.0588\n",
"Epoch [10/15], Step [100/938], d_loss: 0.9735, g_loss: 2.0161\n",
"Epoch [10/15], Step [200/938], d_loss: 0.7590, g_loss: 2.6000\n",
"Epoch [10/15], Step [300/938], d_loss: 0.7545, g_loss: 1.9695\n",
"Epoch [10/15], Step [400/938], d_loss: 0.6759, g_loss: 2.0362\n",
"Epoch [10/15], Step [500/938], d_loss: 0.6649, g_loss: 1.5897\n",
"Epoch [10/15], Step [600/938], d_loss: 0.8588, g_loss: 1.8251\n",
"Epoch [10/15], Step [700/938], d_loss: 0.6679, g_loss: 2.3880\n",
"Epoch [10/15], Step [800/938], d_loss: 0.7888, g_loss: 1.7575\n",
"Epoch [10/15], Step [900/938], d_loss: 0.9048, g_loss: 1.1682\n",
"Epoch [11/15], Step [100/938], d_loss: 0.8266, g_loss: 1.4023\n",
"Epoch [11/15], Step [200/938], d_loss: 0.8397, g_loss: 1.3329\n",
"Epoch [11/15], Step [300/938], d_loss: 0.7491, g_loss: 1.8133\n",
"Epoch [11/15], Step [400/938], d_loss: 0.9517, g_loss: 1.9995\n",
"Epoch [11/15], Step [500/938], d_loss: 0.8492, g_loss: 1.2039\n",
"Epoch [11/15], Step [600/938], d_loss: 0.9957, g_loss: 1.6000\n",
"Epoch [11/15], Step [700/938], d_loss: 0.6942, g_loss: 1.1894\n",
"Epoch [11/15], Step [800/938], d_loss: 0.7000, g_loss: 2.2242\n",
"Epoch [11/15], Step [900/938], d_loss: 0.7945, g_loss: 1.6052\n",
"Epoch [12/15], Step [100/938], d_loss: 0.8775, g_loss: 1.5036\n",
"Epoch [12/15], Step [200/938], d_loss: 1.1906, g_loss: 1.6118\n",
"Epoch [12/15], Step [300/938], d_loss: 1.0698, g_loss: 1.4668\n",
"Epoch [12/15], Step [400/938], d_loss: 1.1755, g_loss: 1.7004\n",
"Epoch [12/15], Step [500/938], d_loss: 0.8775, g_loss: 1.9998\n",
"Epoch [12/15], Step [600/938], d_loss: 0.9339, g_loss: 2.0696\n",
"Epoch [12/15], Step [700/938], d_loss: 0.6873, g_loss: 1.9389\n",
"Epoch [12/15], Step [800/938], d_loss: 0.8550, g_loss: 1.9689\n",
"Epoch [12/15], Step [900/938], d_loss: 0.6931, g_loss: 2.1201\n",
"Epoch [13/15], Step [100/938], d_loss: 0.6622, g_loss: 2.2526\n",
"Epoch [13/15], Step [200/938], d_loss: 0.6650, g_loss: 2.4257\n",
"Epoch [13/15], Step [300/938], d_loss: 0.9299, g_loss: 2.2868\n",
"Epoch [13/15], Step [400/938], d_loss: 0.9252, g_loss: 1.6538\n",
"Epoch [13/15], Step [500/938], d_loss: 0.9582, g_loss: 1.5898\n",
"Epoch [13/15], Step [600/938], d_loss: 0.7105, g_loss: 2.0934\n",
"Epoch [13/15], Step [700/938], d_loss: 0.6426, g_loss: 2.4876\n",
"Epoch [13/15], Step [800/938], d_loss: 0.8371, g_loss: 1.9572\n",
"Epoch [13/15], Step [900/938], d_loss: 0.9026, g_loss: 1.5870\n",
"Epoch [14/15], Step [100/938], d_loss: 0.8441, g_loss: 1.7409\n",
"Epoch [14/15], Step [200/938], d_loss: 1.1538, g_loss: 2.4822\n",
"Epoch [14/15], Step [300/938], d_loss: 0.8320, g_loss: 2.2448\n",
"Epoch [14/15], Step [400/938], d_loss: 1.0065, g_loss: 1.7845\n",
"Epoch [14/15], Step [500/938], d_loss: 1.2467, g_loss: 1.5347\n",
"Epoch [14/15], Step [600/938], d_loss: 0.9260, g_loss: 1.8226\n",
"Epoch [14/15], Step [700/938], d_loss: 0.8086, g_loss: 1.5104\n",
"Epoch [14/15], Step [800/938], d_loss: 0.9717, g_loss: 1.4188\n",
"Epoch [14/15], Step [900/938], d_loss: 0.9018, g_loss: 2.4415\n"
]
},
{
"data": {
"image/png": "iVBORw0KGgoAAAANSUhEUgAAAxoAAABVCAYAAADOppJ2AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy81sbWrAAAACXBIWXMAAA9hAAAPYQGoP6dpAACitklEQVR4nO29Z2xcaZodfCrnwErMQZQoKrda3S119EzP9PTE3ZnZCTYW69312guswx/DMPzLhmHAsA3DsOG0cFrbi/Hu7M5Ojj2dt6e7p1uxRYmSmDOLrJxz1fdD33n01lWRIiWSombrAAQlslh173vf8ITznEfXaDQaaKONNtpoo4022mijjTba2EHoH/YFtNFGG2200UYbbbTRRhu/emg7Gm200UYbbbTRRhtttNHGjqPtaLTRRhtttNFGG2200UYbO462o9FGG2200UYbbbTRRhtt7DjajkYbbbTRRhtttNFGG220seNoOxpttNFGG2200UYbbbTRxo6j7Wi00UYbbbTRRhtttNFGGzuOtqPRRhtttNFGG2200UYbbew4jFt9ocFgAACwv59Op4NOpwMA1Ov1pt/JmxuNCIVCsNvtSCaTSKVSaDQaqNfr8lrt3/A9+e/NXqfT6aDX6+Ua1Nd2dHRgYGAAtVoNCwsLSKfTG34Ood6b9mcb/X8raPVZfxXxsMeO76W9Dr1eD5PJBJ1Oh0qlglqttuHrOeeMRqP8W6fToVwuo1qtNv0d14XJZILJZIJer4fBYECj0UChUEClUtn0eq1WK5xOJ3Q6HdbX1+/rXvcb1DW9F3jYc+5+oNfrYTabodfrm+bVXuNRHLv9gvsZu5GREQBAJpOR/aFYLAKA7E8cX+5BZrMZPT09sNvtWFpawtLSkvye39VnYjKZ4Ha7odfrkUqlUCgU5H1NJhM8Hg9MJhOq1SpqtRqKxSJyuRxMJhNCoRBsNhssFgtMJhOee+45/IN/8A9QKpXwH//jf8Tly5fh9Xrh8XiwtraGK1euoFAoyD7o8Xjg8/lgMpngcrkAAAsLC4jFYmg0GjJmfP128KjNO51OJzZVrVbbsT3xft7HZDIBuD3u9xp7XrfRaITP54PZbEYqlRLbrtVZqbUda7WafI72jNXr9dDr9XItOp1O9sJKpdK0F3LO6vV6ma8bjYX6OZzvPIvud961mnMb2Ri7BY6tav/uNbbyuVt2NDYzvjf7MK1jsRNQHQzt9anOBhfwVj5b3ZDVCbvXhtG9sNcTeT9ip8dA3Xi0P9tsXrf692bY6lzc7Lra+KuDv8pr/K8quEds5dnzdTxfaUSpATOTyQSDwYBarbahw0pjUDUI1WvgeWu1WmGz2WAwGKDT6VCv11EoFFAul1GpVOTMrVarTUabatDxWrXByf12zv5Vx0ZBtnvZgdq/3+zs2uh325kH2z1Tf9XANX8v3M/6auWM3S+27GhYrVY0Go27ImybXUS9XkcqlUIul0O5XG7puW+WWVAHkTes0+ngcrlgs9lQKpWQy+UAADabDXq9HsViEaVSCYVCAaurq2g0GhIV2gzd3d0YGBhANpvF5OQkCoUCDAaDeNdab/lhwGw2w+12A7gd9SqVSg/5ivYeJpMJFotFnquafbjXYtgoK2YwGGC1WqHT6VCr1VCr1aDT6WA0GtFoNFCtVpsiIcAdZ5TfN3OmOe9b/b32etTrtFqt8Pv9YgD8KuBRPxS0Duhu3E+9XkelUpH5uBtoG3b7D5lMBo1GA6VSSaK+2uwocHvOqVHfaDSKVCqFbDbbtIdYLBY88cQT6OnpwcTEBK5du4Z6vS5RY351dnZiaGgIxWIRS0tLyGQyEiE2GAxwOBzo6urC17/+dQwMDGBsbAyTk5MIh8P47//9v6NYLOLChQtYX1+H2WyG2WyWs8lkMqFSqaBer6NYLCIej8NgMCCVSgEA8vm8XPOv0j53L2gdxIcJrdNnNBrljOVcpMPK1zcaDeRyObG3gGZbzmg0StbNZDKhVquhVCqhXq+LU6s6nFoHRh2TarUq+5Ver78rC9Eqk6I1kDcKDO70+G9k3271M5ih2SwwoH3fje5BtZ03G4+N4HA44Ha7US6XkUwmHyizvmVHg+k1fthWLrReryOfz9/18808sFZUJe3rbTYbPB4PMpkMcrkcdDodLBYLjEYjqtUqSqUSSqUSyuXyhteq/ZnX68Xhw4cRjUYxPz+PQqHQlPbbD46G0WiE0+mEXq9HoVD4K+doqE5BvV4X51XrjG7n/fiMzWYzdDqdOKUqzUnrKNxrwWp/1soJ2YrDbTab4fF4HvoBvF+zaJs9793KAjGTutvOxm7uN/e7XtrYXfCspJOhPhs6HWpGgHtTKpUSaonqmBiNRoyMjOD48ePI5/MYGxuTfYxOhk6ng9frxaFDh5BKpbC4uIh8Pi/XYLPZYLPZEAgE8LGPfQzHjx9HrVZDOBxGLBbDpUuXUCgUkEgkmgxO7qkGg0FshnK5jHK53BRw0f77rxLuhyK2G9DuAQaDARaLRc5Y/sxsNksQRA3gcm6q2Sk6EyaTCWazWeyyRqMhAdxWgWet0cw5zvfVMlk2yr5tdn/3+vlOQcuQuNfnqeO2HZbEZu+npYltlV2k0+lgtVrh9XqRz+fvKj3YLrbsaDidTnnotVoNwWAQw8PDKJfLmJiY2NKFPOhGwgErFouSveCglUqluzh8G0WwW3mAqVQKU1NTyGazsmHzweyXDaFarUoG52Hxth8mOP+4YbVyQkkX6OnpgcPhQCQSQSQSuSvioX3PYrEoBzk3Ki31Tv2unT9GoxFGo1E2YuCOUapGbraDUqmERCLx0A/g/WqMbnZdu3XN2kP1UcRW0+1t7C2MxtvHsc1mg9FohN1uh9frRaVSwfz8PLLZrNRqaKPBNLC4f5nNZhiNRszNzaFSqWBlZQWNRgNutxunT5+GzWbD3NwcIpEIrFYrkskk6vU6jh07hkqlgqWlJUQiEXR3d2N0dBTBYBBLS0soFAqYnJzEysoKstmsUKe016J+Mbrt8/kQCARQLBYRiURQqVQkUl6tVu9Zs7YVbJXa8zCx3/ePer0uZywAmVekxGmfNXD3WKtOBOcqHQz19erc5d9paySJjRxSdT9jvSXfq16vS40k70trbO/WXqje41aetxrUfBCbU/tMOD7byd4wm5VKpZrWN2Gz2aR+dCvYsqPh9/slnVOpVHD48GF89atfRTKZxP/9v/9XHI2NBpWTaaOb3YrRwAhMNptFLpdrei/t/zf6fF6fNmK4srKCtbW1pt9xUe2XTaFcLiMWiwHYP9GQ3Ya6MTUat2lMKkVAu4D0ej3sdjuefPJJ9Pb24oMPPkA0Gm16huo84DOm48ZCN/5M62hsNLetVivsdnvTRsYDltSBzdDK+MtmsxIBbGN/YKdT7Q8Lvwr38KsG0ia8Xi/cbjcGBwdx+vRpJJNJfPe730U+n4fFYoHZbEalUkE+n78rQ8H9y263Q6fT4erVq7hy5YoYjsFgEJ///Ofh9/vxi1/8ApOTkyiVSlhdXYXP58NLL70El8uF1157DZcvX8axY8fwhS98AY1GA9euXUMymcS1a9cwOTkpQRVSixuNRlO9B/dZi8UCADh06BCefPJJRKNRvP/++8hkMrDb7bBYLMjlckin0w88L1U7Y6eygjvJVd/MON/tz94qGLBVM/6kvgF3zio6xvyZ+m/+PZ1Ho9Eo9GRVcIVzhA601mklNnI61NeSqmW1WgHcDtRVq1U4HA5x2OPxuNwfg0baDMhWsdXnuJ3ndi9nu9Vc2GhsHtRhoZ0N3G1vut1uDA0N7byjoXq4jECkUinhcxL3E2Xc6oJTX69OsK0uQi4QpqjUtFsrT3o/HsZ/VRwMolU2gd83W2CFQkFqg1pltpi65etVr3+j5691UFp9Nje67aQpN7t3bthttNHGg4OFzCodcjfUf+4HRqMRBoMBgUAAnZ2d6OnpQSAQEKOO18roLPcxr9cLq9WKdDqNTCbTlE2oVCpNhl2tVkMul4PZbBb6Lesu+Z4GgwF+vx+Dg4Pw+Xyo1WoS5GKgKxAIIJ/PI5FINEWrrVar0G7U9wQgzhGDJyaTCU6nEw6HA41GY0ccDWInn+N2MoA63Z0a0mKxuKP3tNtQi/xVxxG4+/zlnKTQgBqJV7+zplI9U1VnUJ0f2vdv5QCoGRCej9r6JW3WWb0elRKt/cydwFayF7QjdjKIrY6b9mcP8p4bvQeDDFt10nSNLV6N0+kEcDvqwmIhm82GSqWCtbW1uwquWxlr92PAqxEA4n69e9XJMJvNAHBXQfG9ru9+P3c/Q3vf6iJvtRjU320Huz12agSGMo2ZTAaZTKbpNaQV8BBWoW4CWuUUHqLlchmFQkE2Lp1OB5vNJr/3eDzCY1b5ztrP4ZioDvBGP9tudG6/z7ntbrb36/z/Kq7XvcJej91uU0oMBgNcLheMRiNyuRwKhQIsFotIrabTaeGkPyju5z5GR0dhNpvxxS9+Ec8++ywsFgvsdjsWFxfxb//tv8X4+Dg8Hg/cbjdyuRwikQgcDgdefvll9Pf348MPP8T58+ebxC0Y1SUTwev14sSJE7BYLFhYWEA8HofD4YDP54PH48GJEyfg9XrR29uLYDCIlZUV3Lx5E/F4HJcvX0YqlcJzzz2Hxx9/HOPj4/jhD3+IQqEAl8sFs9mMrq4udHZ2IhaL4caNGyiVSpJtcTqdcDqdkvEwm804evQoenp6cP36dbz33nvC5d8u1Az3XmcAVJhMJnz84x/HqVOnMD4+jjfeeGNPaynvd83q9Xq4XC44HA7h5Ks0Yr63GlALBAKw2WziZJTLZWQyGXFM6/U6ent7MTg4iFwuh9nZWZRKJZFHLpfLYjfSyaHTS+lm9Yzga0wmE+x2O+r1OjKZjDjStVqtpZwuac3aWkxmNmgDbNee0Tphreo6W/2N3W6HyWRCoVDYVKiolV22G3N7u/subSg6kMlk8p5/s+WMBouuXS4XDAYDstmsqDpt9SL3k2ev6oyrBcXA/s5obIb7dQA2iihs9FotbWk/QL3eWq12F11K+9pWDizRagy4uJitoP48D1FuZjQOqtXqPYu6Wm0k6v/3y9juBtRn8Kt8n21sDTvh3G2U4QTuKDVRBUfd/81m87ai1rsFXp/f70d/fz+A23u5xWKR62VGg0YXX9/d3Q2Xy9WUddWCjsfCwgKMRiNisRhyuZxQYyqVCrLZLIxGoxSIZ7NZxGIxRKNRRCIRZDIZ2Gw2DA0NIRqNymfRiHM4HOjo6BAGRLVahclkQqNxR6XIYrHA7/eLuInX64XNZntgqsd2x5rju5NgRurgwYOIRqN3CXk8bEdoM7BwWw2+qetCex6q2QqdTodCoSABOL7WYrHA7XbLvdJ5Ual1/BwATc4EKVBa1UeuYc47VaCITol6vtPR5nuqims7bevxczcLDNJW2CwbsNd70XbPYUpabxVbdjQIyp3dK8K6lYvmw1Y9QpWrV61WmzxUbgpbje5uZLixoFj1ztVUn9frhV6vRzqdRqFQ2NJn7RRapfJVnuRG926329HX1wej0YiVlZUNvcxWh7G2IQ6jCEBrFbCNfrcb2OpGoDUU1HogbURAzTDQyOBmxtcxAsLoIKNv/f39mJmZwS9/+UvU63V0dHTAarXizJkzOHr0KBYXF/Hhhx+iUChIliObzSKbzd6VrtVm+xhtadV86FcNrYqqW2UuW/1bBQ8lAHel0dt4dLDdvUSbEeThbTab4fV6JShgNpuRTqextrbWROfh+qpWq1Jf+LDXXCQSgdFoxCuvvILJyUmJDKdSKSwvL8v185AnDer8+fOYnp5GNBpFZ2cnSqWSRJbVAl6qCCWTSTljdTod8vk8VldXYbFYUCwWYbfbkU6nMT4+joWFBUxMTCCXy0nwJB6PY2pqCuFwWGpCqESUTCZhNpuluNxoNCIYDMLpdMLlcsHtdiOfz2NxcVEkMycmJhCNRu9pfG0FWwnSuN1u9PT0oNFoYGlpSXjo94LBYIDNZmuKiKvZf9ovXq8XoVAIXq9XCpF5bx6PB06nE9lsFmtra/ecc5vRdXcKrWoWgdt7K51c9eykDZhKpVAsFnHmzBmcPn0aS0tLeP3115HJZOT8TKVSUgdULBab3puqZI1GA5VKBQaDAY8//jhGRkbEKSiXy1haWkI+n8fy8jIikQgACFNApf3xfbXF4Px5pVIRaqG6Lu7XqG9lG23FLlZ7z/CzWzFINspobPT594t7BWR5XQ/yudtyNJge26n0Mh0NvrfRaJSFzMOAUR51A1ENlI0M0Y0eCg8mbrJcEADE6/X5fDAajSiXy021KXsB3i9wZ9LxZ61kDwmbzYbBwUFYLBZkMhlxNFo5FuqYMaKn6lrfK9qy1+MBbL3zpRrNUCX01AOBToXZbBaNb23HUWYn2MXW4XDg5MmTOH36NEwmEy5evIharQa32w2Px4OzZ8/ipZdewjvvvIM333wTmUwGoVAIVqtVDAL1GlvR0ejwbfa6XxW0crRabfj3un8+K+4ZbUfjVx/qWlb3SGYTu7u7Ybfb4fF44HA4sLy8jEwmI0YJC5hVp34/rLV4PA6dTod3330XFy5cQKlUkoJvVRJUNa4KhQLGxsbEoA8EAkin04jH40JfUe+tUqkglUo1nX3FYhHZbFYMQ5PJhPX1dXi9XqTTaYTD4aa+GpTBTSQScjaRhprJZISyytoNn88Hv9+PUCiEnp4erK6uYmJiAolEApFIpClbvBNS3vd6jg6HAwcOHECtVkM8Ht+Wo2G326HX62UecS4yQMjzwu/3w+VyNVHN1fqb9fV1RKPRe/aBoo2023LXWkeDZ6bqJOn1erH/arWaqI51dXXhxRdfxNjYGN577z3JijGLxToVtd6QwVOejwzynjlzBi+99JLMh1wuh6tXryIajQK4Q2+ko6HWH/FeaD9pKct8vXrP2n8/CLYShG00Gk1Bbo6FNnDC63qYexLn9mb3slVsu4/Ggxzm2oHTbu70CPV6veh3c8LV63Vks1n5PT1UypJyk1J5b62cD7UISb0GvrZarSKTyUhKTjXK9+KhtzL2OS6tor+qQc2IGO9fXdTcIHlIUbawWq2KdjoPDL/fj0OHDqHRaGB+fl6KDLPZ7K7fvxabOZAco82cylbvxdebTCbYbDY5RCmFZzQa0d3djeHhYTFgTSYTgsEgvF4vjhw5gs9//vNoNBrw+/2w2+04cOAArFarUAd4YPKw114jnzEPYBZb1ut1DAwMwOv1Yn19HYuLiw890rodqJQoVVGEKXF17PV6vazXB1F4I/XxYRuKbWwNOxGlpfHd1dUlTaVU/rfJZEJHRwdCoRA6OjrQ3d2NfD6P6elpZDKZpgZ3NIpUdTh1X9mrvZ/ZfMpwqllWjpXqKJGudOjQIekrlUwmm+rCNrpuvV6Pjo4OOJ1OdHR0oKurC+VyGSsrKyiXyxJ5Vzn0TqdT9sdCoQCv14uPfexjyOfzuH79OhKJBIaGhvD4448jl8thcXFRDNNSqYRoNCo9NyhtOzo6iq6uLoTDYSwsLOxJoKBYLEqGiwWtGwV/+J02CbMUVqsVlUoFwWAQg4ODEiiyWCw4fvw4AoEAjh49is997nNSp9JoNJBIJJBKpWCz2XDq1CmREs5ms02ZNnUe7rbyJd+7lW3Xqlkti/f52uXlZbz33ntYWloCALhcLvT398PtdmNlZQWLi4uyXs1mMx577DH09vbKPkDn2WAw4MSJE+js7GxicRQKBWQyGbjdbhw+fBjJZBKrq6vyN9rshPb8v1cWYCfH9l7vZbVaMTo6Cq/Xi/n5eSwsLNzlXKjBxlZOEO9xt888rW38INiyo2Gz2QA0F09vB1oDkd9pJHCDZQotEAhIutXn8wm3tFgswuFwwGazIZlMIhwOw2g0oqurC1arFSsrKxtmIVTpUnq22oVcLpcRDoclQsFMwk5ofG8FTG9rf6bN6PCLlIFKpYLJyUm5B9VDNpvNCIVCMJlMiMfjSKfTeOKJJ/AP/+E/RCaTwf/4H/8Dk5OTMhbPPPMM/uAP/gD1eh3f/OY3cfPmTUxPT2N6evqhG3NaahkAifapDplW9k5dMGoBN/nEjIw4HA5YLBacOXMGX/nKV1Cr1TA7O4tyuYzR0VH09fXh0KFD+OpXvyrUKtIQ6KQNDw8jFothbW1N+rKoUS/VqDl06BA+/vGPY3V1FT/+8Y9RqVTwzDPP4KmnnsI777yDpaWlRypKT/oAvxsMBrjdbpHb5Jz1eDwwGo1YXV3F+vq6RKm2u7Fp18tGRsOvOrZKMdwP4J5FGsZ2wfVtNpuFsri8vIypqSkAt2mkNpsNw8PDGB0dhc/nQ29vLyKRCL7xjW9gcnISCwsLKJVKIgXbaDSksFTdb9Vs926PLQ24YrF4V5Eo9wD2juK+7vf78dnPfhYjIyP44Q9/iJ/85CdieG10vVyDg4OD6O/vx9NPP40vfOELWFtbwze+8Q0sLy/DbrfDbDbL2jIajejr65MofTKZxMmTJ/HlL38ZmUwG//Jf/ktcunQJL7zwAv7e3/t7QnWJxWL48z//c4yNjWFpaQnJZFLOU4fDgS996Uv45Cc/iR/96Ef4b//tv21aHLtTSKVSuHbtmqyZjbLa3N85Xz0eDwYGBsQWAoBnn30WX/rSl2C1WiXYSWd3YGAAL730khjSxWIR/+t//S985zvfwaFDh/CpT30K5XIZ3/ve9zA9PS0OmWrw70WQiQa6SrHjzxl955xzOp0IBoPQ6XRytl28eBGXLl2SIu2uri586UtfwvHjx/Hqq6/i+9//PnQ6HdxuN9xuN37v934PL774YpMhy/t0OByS5aDNlUqlsLKygsHBQTz11FNYWFjAL3/5S+TzebkGOrRqVkaFGph9mHC73fj617+OkydP4k//9E+xuLjY5CSpX8DdYkp8Frt5zqlj1Gr+3Y+Ds2VHQ/WiHsST0npoNARpLHJR2+12uN1uUc/g5mg2m6VZCLMZlNXj5qh9CJtdq/bBcoPZ60zGVsDxV6E+Dy60Vt4ux6+jowMulwudnZ3wer3Q6XTweDxwuVyyWK1WK4LBIGq1mjSPelDu7P1iO2m7jTI+6rPUHiCq7rtOpxNlFGYaSHsqlUrweDyw2+2y2ao1RuxSbzab5cvtdsNisaDRaEitT6ssi6rrzaiWNiW8Xey14andyDnfTCYT3G43Ojo65Oda9Z9SqYRCoSD33Iq+t9l9tIpcPYrYKIW/WfS/1X4AbI1y9rD2tZ38XK4dfgEQ46hYLEqBKmVcN6JJtTortOfUTl/7RqChyn1AffZqsIzXwsw+gx2tjCy1+JXGsMfjgd/vRyAQQDAYRLVahcvlgt1uBwB5TxbwMqMC3HF8qCLV09ODSCSCzs5OdHR0SKSadZaU31UdJV47Of+8590GgxPcoxgMcTgcKBaLSCQSTQFQFqwz8ElH1mQyobe3VyiyrGfgszGbzXA6najVasKSYJDU4/Ggs7MTlUpFzmS1b1Kr9bnba1atYdJmAdQ9lpk3zqdisYhSqQSbzSY9U2in+Xw+9PX1iZ3hdrvR2dmJYDDYtM9zPnGecp5ZrVa43W5RRXM6nbDZbLIOQqEQDAaDSC+rUrut1rL2rNjrM4N2GtcB1zLtK15Pq0BBq2f/qGTyt+xoqLw9Ds79bAraGgTgdrbEbreLg2EymXD06FF0dXVhZWVFIumkUfX39yMQCMBgMGB+fh56vR6BQAAejwfZbFZ6e3CTVmlHKqcXuBMN5+KyWq0IBAIwGo2IRCKS0nzY0C4QdSFRy5oLdqPskdFoxKc//WmcPn0aHo8H+XwepVIJhw8fhsfjweTkJBYXFyUywQOMRV8PY0JrP1Ob3QGau4mqzoR6wKppcjoMjLizNojFaAcPHpSiNJ1Oh97eXtRqNaEa0IBWNylugG63WwoCn3rqKbhcLrzzzjv4xS9+0WQ48IuFkCzgbDQaeO+993Dr1i2sra3ddwd4bvgP6rDcC+o64qbHolEeDM8++6x0HCZNis+kv78fyWQS6+vruH79ujgdqiRnK4ejVTp8PwUF7geq7Dbvj4aQmvEB7lCH1KAK570q7NAKqgzj/c6vB8G9Iu5bQaNxm+t88eJFTExMSJ2BTqeT2qtUKoWxsTEZ10KhgImJCaTTaSluVo0dtXZjo6ypNvK9kygUCjAYDDh06BB6enoQj8eFfkTasNfrhd/vF3nbdDqNH/zgB7BardJwVjU+aAyylozBOrvdjtOnT+PIkSMYHh4WOlBnZyfK5TLGxsYwMzMjzppOp8PU1JRQ0txuN2KxGMLhMBwOB/723/7bqFarGBgYkCzw//yf/xPxeBw+nw+PPfYYbt26hXQ6LRHofD6Pb3/723j77bdRLpfR2dm5K+O6EdTz8uWXX8aXvvQlXLt2Df/9v/93xGIxOUefeOIJfOELX0C1WkUikYBOp8Pp06cxODgoZ4KqoqTuTaT+zM7OIpVKwe/341Of+hQOHTqEJ554AuVyGQsLCwgGgxgfH8fNmzcB3G0Y7/aaZTCMjg4DZMzk8f7oJNXrdXmWDA5R3lav12NxcREulwtHjhzBuXPnpL+UxWLBgQMH5J7Uz+d39fM6Ozvxla98BZlMBpFIBIlEQqh7VqsVv/u7v4vR0VF897vfxfe//32h4qo2n8pqoC1HCuBeOxypVArf/OY34XK5kE6n4fP5xKYG7pzX7AN2r4Cblmq1UUBqO2gVqNb+frvYlqMBNN/YVrMG2gvUyorR0DOZTJI68/l8CAaDiEajUhvAxkROpxMejwc2m62JP+l0OmG324U/yQXQKrqvepD8ohNEYzIejz90frw2qqYuDE4INYqizXqo92c0GjE8PIxnnnkGhUJBtLJ9Ph/0ej3W1tYkuk/nhSonD3scVGzV01dl7NTXWCwWyZTxtSzkC4VCGBgYQGdnJzweD/R6PRwOB4Db0RXWKmlBXrjFYpFNta+vD6FQCNevX5fnpRanA0AymUQikWi67pWVFUSj0ZbNBrcKlfKxm+B9qEWLqtNut9vR09ODkZGRJmeKdTF0zgBgcXERuVyuqeZiM665ugaAR4M2tBnUzC73JzrD2n1Mm2ZXDeR7FY+qB+/DiIjxuT4o6vU61tfXsb6+Lj9TM5bA7eJR1WlVjSMeyqqOPseE46KeWdxndwuc9y6XC11dXQCARCIhxlOj0YDFYoHD4ZD6wVKphJmZmQ3Hk/dCmVE6FA6HA6FQCN3d3bLPUVXJZrMhn8+L48IxYKaIzko+n0cmk4HZbMaRI0fEAAVuG1Q3btxAMpnEM888Iz05GKQEbu9N09PTmJmZQTAYRF9f344Ug28HDHr09fXhmWeeQb1eFwlUzqPu7m6cPn0ahUJBOqKPjIxgdHT0nu/N+ZVOp5FIJOBwODA0NCRnQ6lUQmdnJ7LZLBYXFzecY5zXreyZnQIDdjTC+TMGZhmUUzNPam0dMyJ0IjOZDAYHB/HEE0/I2ahm1rT3x/dT7Rq73Y6DBw+iUqngxo0byGazsr8ZjUZxZC5duiTSvLyWzTLdvJ+Nssi7hXK5jImJCcnweDweGVdeF6l2W3UyHoXzb8uOhnYz9nq96O7ulmImVblBVYrSyoa2eqjkPnIzJPUkn88DgBj+vb29sFqtqFarWF5eBgCMjIzA4XBgeHgYPp8PAwMDqFarmJqawuuvv45cLicPkXKjzFoAwMLCgqhw8CEzmqGqAzxMmgHHjZ1UbTYbTpw4gVAohOnpady4cUPSv8AdOgFpaJ2dnfjsZz+Lnp4eHDlyBBaLRag9TN0Wi0UcOnQI0WgUHR0dmJmZQSKRwMLCAtbX17eszLHT49XKoOJmy6wCjVY1W6YaqVqDlCl8bprcIPV6PaLRKBYWFuB0OmW+MdtGZ6IVeF1dXV34whe+gHg8jqtXr+Kdd97BjRs3mhRgNhs3ABJZfRBjjNzq3TSMtM4u51uj0UAgEMC5c+fQ1dWFU6dO4cCBA3Lo8iBgtK9YLGJ5eRlutxuJRAJXr15FPB4XJRvq++8nZ3cnwDlN1TdmbF0uFw4fPgyr1YqbN29icXFR5qcaNdU6Gdr33ojHq1JgtAGY/XxYbQW8X9JVuA44TjyPSIUpFAqIx+MyHupcVoM33Et2ew42Gg0sLi4im82iv78fX/nKV5BOp/HKK69IoTYzMmowTf17QnW6/H4/Dh48CL/fjxMnTsDj8eDQoUMIhULSeDeZTOLKlSuYnp5GOBy+K3vMf1Oq+/r16zAajXC73Thw4AA8Hg+6u7vR3d0Nk8mE3/7t35Z9Vqe7XROn6u+r87NQKCAWi+0ZRVebdXj//ffRaDTk/PN6vTh9+jS6u7tx4sQJdHR0iIqZTqeD3++/6z25r62trUktCh3cUqkkVCs6ixQlmJqawvj4OGKxmNS30eHguaHO3Z1eoxwLBtK0ssjq/M9kMlLcrdY06XQ6+Hw+nDp1CoFAAE899RQOHTqE7u5uYQvcj2HPzCXHgbTboaEhGAwGXLp0CeFwGIuLi8JE4dirTivPKVXVlPbdXtLCmelXG0a3Qqt9Rt37WQNJR4V7Al8H3Dn770d8Yyt2ynbm4ZYdDW2BssvlwtGjR1EsFu+SiOMgANjS5ux2u6XIioo9xWKxydGw2Wzo6emB1WoVPWW73Y6RkRG43e4mR6O7uxuvv/463nvvPeTzeYnyOZ1O4fuNjo6iXq9LRJkebrVaRSwWa0qr7ofDl4a1x+OBz+fDSy+9hBMnTuCHP/whbt68KaogOt3tIq1isShGcn9/Pz73uc/h0KFD0pSHUa1W6cuFhQV88MEHWF5extLSEtbX17dcDL/TjoaW4qY6DzTQmCql8gdwewFri/vUegoAohKiRjeo5+5yuaT4saurCzabbcNFqkZzurq68LnPfQ5zc3P4i7/4C7z99tsti9M2c75bdSzfLnZbvKBVal+VQQwEAjh79iwOHDiAkZER9PX1NUXqCTqJq6urcLvdWFtbEyeDv8vn8/d0dB+lzIY2C8R+D1yXoVAIzz77LDweD2KxGCYmJgDcoae1imKpGWf1S30N0SqjsNnrHzVwLDKZjGj6c1/gnuD1eqWuIB6P35Wxp5GizUTuJmgALS0tYWFhAUNDQ/jyl7+MeDyOK1euYG1tTegpak1TK+NTzWKbTCZREhwaGsKv//qvC/VYr9dLHUsymcTY2BjGx8fvKoonGo3bkqX5fB7JZBJzc3OwWq0YGhqC1+vF448/jjNnziAYDOK3fuu3AABXrlzBysoKrFar1GNoWRHFYlECfHsBda7X63V88MEHuHDhgtgGoVAIX/nKV3Dq1KmmINPBgwebKDfasanValhbW8P8/Dyq1SqKxaLI4ppMJvT09KC3t1cc3EgkIsHCarUKs9ksBjVtJz6H3cpOc67QJsjn8ygUCk0BDM4zqnKq4D7W0dGBs2fPoqurC0899ZTI7bPx3mZoxYzh2iuVSlIkz7N5YGAAxWIRly9fFiloBo+Xlpaasrs8R0jN1+l0yGQyTV3r9wJcjx0dHXA4HEilUtJvhs+WMsib1VnxrGUtrclkkmBcq32c+5k2KHG/96DN9m4F227YRxSLRayvr4u3qULrOaleGL+bzWYMDAyItF5XV5dQp3S6OwVGrMlgFoIZiZ6eHnlwDocDXV1dUtycTCZRKpXgcDhQq9XkIO/t7ZUodUdHB8rlMrxeLzKZjBjw1Bkvl8tIJBJbjuTvJtRoMSMd8/PzaDQaWFlZEU48+dyqR0u966mpKZRKJSlmI53AZrNhZGQELpdLJqjFYpGxGB0dhdlsxvLyMpaXlzdN5W30sweB1pBSNyStwpRqQN1rQXGhqGnfRqOBVCoFvV6PYDCItbU1lEol+Hw+OQBUg4TvU6/XhT/K7rjlclnmM+fyZvenvuejAgYUVMOMkXm73S76+ZRWVjd1jn8ul0M2mxUan8lkwuDgIGw2G1ZXV7G6ugoATXVdreaC+n0/QuscUEPeZDIhEAjA5XLJXujz+TA4OAi73Y6hoSGsra3JHlqtVrG2ttYUCSO1AbiTcd7PY7Hb0M4x7R4B3D6/MpmMjKM2U6Qdx70YT9ZVcZ5ks1lcvHgRqVQKqVRKMoI6nU4itpwTWqeAgRhKZR89ehSHDx+WoIlaUxWPxzE9PY2JiQlks9l71tBoKXeMFDudTgAQ+iNrOyiSwc9kc1mz2SxGYC6Xk0j0XoLPOxgMIhgMwm63i/Kgaq+o61dbxFytVpHP5zExMYFMJoO5uTmEw2GpySP9loyKQCCAer0ucrmPPfYYXC4XwuEwVldXJbuzF0pnwJ25TdrTZiwUdU1wXNi/5cCBA+jp6ZFxVG0RFTR42WODTSlJB9Tr9ZL14evK5TKmpqYwNzcngdRKpYJ8Po9KpSLObyqVaikRzO9U5NQGpnb77KUAg9lsFjuuu7sbg4ODSKVSmJubk7miiu+o18Xas2AwiP7+flH4osgAnVk69MvLy9K2wGQyNfUMul/c7354X44GI79sxKI1orTet7pgaRB7vV781m/9Fs6dOycF3DSMy+UyotEoUqkUent7MTIyIsYLowJ+vx/xeBzLy8vStdnlcuHWrVu4ceMG4vG4HNpdXV1wOp04d+4czp49i3Q6jZmZGaTTaRw6dAh2ux3Hjx/Hk08+iXQ6LdzSixcvYm5u7r4GdifByUOHqVwu45VXXpHoQj6fFyUMo9EoPHjKR4bDYXz729+WSAD5suPj4+ju7sY//sf/GCdOnJCNg0VcPKQSiQS++93vYnV1tWlRtpq0u+VoqGoS/DnnHa+J6VCtodUqUqulUnBzmp2dxfLyMiqVihRHdnZ2StSAm6F66FSrVVy7dg2XL19GKBTCkSNHkE6n4Xa70dfXh0gkgmg0uudO2m6B987CUPZuYUTO4/EgGAzi0KFDOHz4sNStaNFoNLC8vIzZ2VlUKhUUCgVYLBa89NJLMBgM+MlPfoKlpSU0Gg2RPHxYogTbhXpAqNk37nGMRtlsNhw/fhw9PT04duwYnn76aRHH4P329PTI2ozFYvjBD36AVCol78/6IuAO7W67+FVxTnhQa2mWalCi0WggFotJQbga+dfr7zQlUx2VvYDb7RZD3Gw2Y2lpCf/m3/wbCX7RUGDROLOs+Xz+rsAejY8XX3wRJ0+exNGjR3Hq1CnJmqnZ4evXr+NP//RPsba2hrW1tbsEGDYCx5psA1KmwuEwIpEILl26BIPBIPK7/NzOzk588YtfhN/vF4Px8uXLeP311/dMRp73x+DcmTNn8OKLLyKbzWJ+fl6cPgbx1Iw6z1Ua5oVCAVNTU/j3//7fY2pqStS6OHdIa6YCVVdXF+x2u6h9/d2/+3dRLpfx+uuv44033sDKygrW19clq7AXY0H6GilKQHMNgFqDxzXDLM8TTzyBj33sYwgGgzh27BgcDgf8fr9E57WfRRW42dlZoclevXoV6XQadrsdFosFwWAQBw4ckD2zWq3i7bffxoULF+D1ejEwMAC9Xi81TOvr64hEIk0CImpGhmc8o/7A3QGJ7WI7GWCLxYJAICDrz2w249y5czh37hzGx8fxf/7P/5FApcVikaJ81alzuVxwuVz4+Mc/jq9//etwOBxwu91oNBp4++23MTY2Bo/Hg66uLkSjUXz729/GwsKC1C1z3Ldzr1pGz/2O1bYdDQ6uKieo/R0vSIU2oslUW1dXl3jvTP+wQzejJGrdBhV9AoEAdDod8vk8LBaLFILzwGWazGw2w+VyiWwpD3Auej50Ni4C7tB0eIDvRMppq2CdSqPREG9fXfDc6JLJpKjzqMa3NopHnmcikZCGVrXa7eZ+yWQSTqezifupfS+1OJyTbi/pZJt9jja7oP5sq++lzWzwAMlms4hGozCZTKLORZ6tWmzKv6XWNwBJjatR6/vlNu5X0Nli4SCLKu12O7xeL9xut8gdblTgyYBEqVRCsVhEMpkUA4q1Htq1t58pPq2iYloqE794mLpcLuG1d3Z2ilwj91fKO3Ldqw5uq3FQD9hHLUO2XdAop0IOcLdEpzpG6v7G12nFGYi9djKAZmqc0WhEPp/H+vq6rC3VUW21B/NnfK3ZbIbP50N3dzcCgQC8Xu9dwhgAhP5MZ+Ze98zsuirlbbVaYbPZUKvVpBkiqV25XE4cY0qpq/uoSlHeq3O21T3xbHQ4HDCZTGIU03FlRJxnMyln2WxWGtOxwaqameF65j4H3MkGU3ym0WjA7XY32R0MKu72mKgG970i3uoeRnuOUrYMkLCmUftM6fwnk0kkk0msrKxgeXlZ1NUymYxkfUqlkth7/DtK2HLOqJ8PoKkOslXWrVU2Zq/Wt3YvqtfrsFgs8Hq9G1LYeZ0MgnR0dMDn88Hn84kty2CD1+uVTBKdFa5T2tCkku7UfNrO+XLfGQ3g7ggxF47abIUDzJun4csUHTdO1kZcunQJlUoFZ86cwQsvvCDvr9frRZnKYrFAp9OJ/jS9PYPBgIGBAXEqFhcXRdXBbrdjfX0db731FrxeL4aHh1EsFnHlyhXJqHDynz9/HvF4XNQo0uk0otHonmyCp0+fxu///u+jXC7jv/7X/4pr167JWLOREw1itS6B9B06X1q5W0b/r1+/jkqlgp6eHjz//PPo6elBR0dHU2o4Eonggw8+QCQSwS9+8Qup1VCzC/spAqpuJq2iFOrvVag0HH5n1oId0fv6+kRqkp3B1e7fOt3tZn03btzAK6+8goMHDzbRiAKBALLZrBSdqwfQfhm/+wWdAqvViq6uLlgsFgwODuLYsWPo6uqCy+Xa0LnjYcyAwPz8PH784x+jUCjA4XDAaDRifn4eiUSiicPKQ7iV9O1eQ2vsqUV3/D0zObxeZnQHBwfxB3/wB+jv7xcFPZ1Oh3g8jmw2i8nJSdmTqEjDqF80GgUAMdRoAAHNWcZHfX5tBtJ1Xn75ZZw6dUoMjLW1NbzyyitioGv3KRoglPBW+d/cA7aiw78bYKQ4n88L3ZIR946ODphMJsRiMaRSKdmnVOOQmQyLxYKOjg7JKh47dgxer7fJAAPuODbMmGsDIrxvLcWEVBnyxJ1OJ7q6uuD3+zE+Po7x8XEMDg7i93//96HX6/HGG2/gjTfeQHd3N37nd34HqVQKb731lkjH1+t1qcvazfHlfaj3yLGbmpqCXq9HKBTC8ePHYbfbpWbl0KFDkn1ZWVlBNpvFhQsXMDc3h1gshpWVFaTTaSwtLW3oqHEuMrBAR0LdM8LhMD766CMAwNGjR1GtVjE5OYl4PL5rYwJA+qZoaVNAM60KuLOn0e4wGo3SGfzw4cM4cuSInH+09ZgVslqtyOfz+NM//VO8/fbbyGQyiMfjKJfLSCaTqFQqYhxbLBaMjY01NXddXl6WzyfF7cCBAzCZTLhy5YpE7EndU+e7dv1y3TxIQGYrc5XvX6lUEI/HpV7HbDYjHA5jaWkJ0WhUnPJMJiOvbzRuN0g8cOAAvF4vXnrpJRw7dgyJRAJvvvmmOCvcHx577DFMT0/j9ddfF/p/R0cHPvGJT+CZZ57B5cuX8Sd/8idIp9MPfI9q8HkruK+Mxkabrqr6Q8+fF6MaCGoEWY28FwoFLC8vo1wu4xOf+ASOHz+OVCqFSCQiRZOMhPCgUWVKGRWwWq1IJBLweDwoFotSTJ7JZBAOhzE4OIgzZ87IAmC0gZKv7Gja19cntRx7ha6uLnzqU59CsVjEt771LbkvLgz2ISBoXDcaDdFd1tYdMHJXLpexvr6OeDyOjo4ODA4OiiqEOoa5XA6Li4tYXl7GpUuXmuhjDzPqtBVoD8VWRob6f+0cpiOQTCaRTqeluI8Lmn/jdDqlaI8ZIh5WR44ckUOEWbZWvNBHFWpEi44/mzENDAzg6NGj8Hq9sNlsGzqkXPPcM7LZLMbHx5FKpZooLNo0uJpB2Q/QOhaqko6awWWGgj9jn5VDhw7JeEajUaysrCCRSGB6ehrxeFwig5FIBOPj4021GWqRnzYS+SjPr62Ac290dFRkSdm/4Z133rnL2dKOByP+2vOIr201fru9dtV9HoAEkqg2aLVaRfFJfZ16fTTEHA5HU+NRRn3VPUjNnpAGo6X8aQ0x7ml+v1+yGg6HQzjimUwG8/Pz6O7uxpNPPgmDwYDvfOc7uHDhAj7zmc/g9OnTmJ6exo9+9COh4qr3v9tQ710dx1gshpmZGRiNRgQCATidTqytrSEWi4nUcK1WQyKRQDwex40bN3Dt2jWEw2HMzMxsuSbQYrFIcFQbxc5kMlhdXYXH48Hg4CCA24XNuw0t7bJV9p3rQ6WR8SudTmN+fh4dHR1yJvJv6WzQ/iuVSvjoo4/wyiuvbDqH+W9KzpvNZqmXVRX6SENbXFwUO4aUs83mU6sgwm6A90NRE7U/D1XH6BipVG5eH2v4QqEQTp06hbNnz+KXv/wl3n//fak3MZlMOHv2LDo7OzE9PY2pqSkUCgU0Gg3YbDYMDw/j7NmzyOVyG6pm3s897aqjoW7G2rQ0jVk1VcbJxoHs6urCE088gWAwiNHRUZFYpdHxxBNPoFqtIhAIyGfxsOXEpnEDQCL7lCy9fv26yPPdvHkTJpMJBw4cQHd3N5aWloSOxOJTppbW19fxl3/5l8LdJT2pXC7LBN8LKsLy8jJ+9KMfoVKpiD68SgfQHpwcW9UB4OvUBUujhR3Xqc7V2dkpGSI+R6/XizNnziAUCuH999+XInCtg7gfoBp6Widoo2vkPNJmGFRwjnm9XgwODmJ4eBh+v18khMnvpmAAxzeVSuHSpUui4EEHhRvIZnOImziLg9nIbr+MNQDJJAaDQVk7NpsNhw8fRn9/P3p6ehAKhZrS57xnOvLZbFbqoFgTMz8/31Rzo34xyMAUOtf8fhgX9Rq0hxvnluooDQ8Pi7zo97//fdjtdnR0dMButyMejyMcDiOXy2F+fh75fF6yv2tra3fNVfX9Oc4cM5WW8jCa8u0WdDodvF4vjh8/jmAwiOPHj6O/v18imSxIVucP/6+CPV1ayU63mld7kSWiBHQ4HJZMHp1IquGVy2WpV9qIb93T04MvfvGL6OnpwYEDB2QP0hq25ORTFMRqtd5lPJBWzHOXkWlSQxmJnZ+fRyQSkdqCeDwu5y8zBbVaDXNzcyLTazAYMDIyglAoJI15d7MYfLNnl8/nEY1GMTAwAL/fD7/fL0Ie2WwWr732mkhvJ5NJTE5OYm1tbUvRYdpGPMM3Ahua6vV6hMNhALf3zN0G912tk0GogRTVpuOzZ1CZwV+KDQCQzMfa2hq+973vYXV1FTdv3ryn2ADpWFThI+W9Vquhu7sbBw4cgF6vx9zcnCim+Xw+pNNpJJPJDTMZrYrTd3NNt3pvsnvW1tZw/vx5WTPqmcb9u1arYXFxEYlEAq+++ipmZmawvr4uqqysS8lkMrh69ao47wz4GwwGTE5O4pVXXsH169fvqv2433va7rlyX46G9iHy563qNlSDuFqtoq+vD3/rb/0t9PT0wOfziSIN9bhdLhfq9bq0qKfnxOid6s2S81goFLC4uIhkMokf//jHeO211+ShBYNBuN1uDA0NIZPJYGFhAaVSCclk8vYA/P+fu7CwIJX/9IgTiURTM7W9wPz8PP7sz/5MJD8BCBVNa+BrnTit8cXnw0yI0WjE6Ogo+vv7MTw8LJKELNLjRhgIBODz+bC4uIhvfetbwldVaW57hc2iiJttipuB84iZnlZgFNHn8+HgwYM4cuQIXC4XHA4H4vE4VlZWkMlkMDExgUQiIYZAIpHA+++/D4fDgbNnzyIUCkGn08mYqYWq2mfFuT0wMIDe3l5MT08jGo3uuRLLvRAIBHD06FE0GrfpfBaLBcePH8epU6ekQI38WhX5fB4rKytYXV3F97//fczNzWFubq6lmpnq2JpMJrhcLgCQLvX7Adq51uqg5rPjfnn48GF8+ctfxvz8PP7f//t/iMViGB4eRiAQkOytGtlKJBLCq1W57Py8VrUIjGqrqj77wSl7UPA+/X4/XnrpJfT39+PMmTM4ePAgUqkUYrGYNB1VqVDqvkmqCilT2wme7PYYHj58WJq7qcEdACL1Tg68Sj1WDUEA6O/vx2/91m+JZHwrOdZG447iW6VSgdPphMPhaKrFA273VvD7/bIfUviBilL8P2ley8vLKBQKiEajuHr1qgSxuru7hQoUiURQLpdhNBpx6tQpnD59Gh988AHm5ubue6/barZJ+3v+P5vNIp/PI5/PIxQKoaenB52dnajX6/jFL36BV199VQxD0lu4r29lXvDc3MiJbTQaoqLESDWwN46GNkuqDdi1svWAOy0PaPfpdDqhNHFekgq1vr6OP/zDP5Ro+0YOF/cvioo4HA709PTA5XJJPW0wGMTIyAhyuRx++ctfYnp6uqlul2tHDSjy81RHmufwXjq3dKKsVitWVlYwNzcnToNag0eHnllanU6H9fV1yVJ2dXUhl8thYmIC6XQaH330kaib+Xy+puD8+Pi42CkbqV9uF+qYbgX3LW/bCtooOtCsOMWfq4XN5XJZioGAZgUV8prV5mMmk6mpCIuc5tnZWcTjccRisaaGZ8ViEYlEApFIRAq7VAWJQqGAVColC1zL29Nu4rsNjgdTjuqYtTo41YOyFdT0uNlsRnd3Nw4dOoTe3l643W7hw/O1Ot1tOcK1tTUsLy+jVCqJUb7dybUTuFf6czvPRX2matZH+xk0+i0Wi+iAs7hK67yFw2GEw2GRn+R7MgpPPqZKu9oIHN9isSgNuR6EQ7pbYOG2w+FAX18fnE6nyCPTWVKLASlBuL6+jsXFRYTDYayvryMajUr2UIUamee/WfO135wuFa0kCXngkdIJQPoAcZ9idpXRdVVmknuSOm+4f4ZCIfh8PmQyGaytrTUFANQAxK8KuBaoBtfd3S3GcT6fx9LSkkhS3ysD0coIedigsUH6CbPPrGFgg7FWEWYAokxImpVaA7ARSDWhPHcr3jqldEn9c7lcUoBPJoLX64XZbJaeVDxbmXkplUpSbJ5OpyVDUiqVkM1mxbjeSDjiXrhfJ1Bds43GbXnzjz76COFwGA6HA2azWVgOaiH3VhxTdb4ODQ1JTSmDfnTC1NeqAVX+fLehzqeNIv+q3ca/4ReziaTrkGFCYZVarSaZWva80oL3b7FYpF8Ya2u9Xi9cLhd8Ph88Ho+cqaVSCXa7XRxgBmO1Uv+t2AT8HefvXgZiuK+zzspsNqOnpweNRqNpLWj3Js4/i8UidVyqkwfcDmQWCgXYbDb09vaKWIbFYhGxgr1SdlOxI46GNhqpOhk0stQCIWYiOCkuX76Mt99+G36/Hy+88AI8Ho9sVOl0GrFY7K7sRrVaxcrKCm7cuIFYLIZf/vKXoqTE3+fzeeh0Oly+fBnRaFQKyjn4xWIRS0tLGB8flw7FKkVLjXTt1URkzwvgTsRAVb/Syleq16Y9eFT1EW5yL774Ij75yU+io6NDitLIzeXYLi4u4jvf+Q7C4TCi0SgsFossjr0ci61gq9eiOrtaTnurw9tqtcLr9UpHWEpP0oCjktdf/uVfSsEeVansdjtcLheCwSC6u7vR0dEh3XdVI6hV9LtUKmFtbQ35fB7pdFqey34CKQPHjh3D7/7u76K3t1cMZZ1OJ8Yf19Dy8jLW1tYwPT0t6/TKlSvSGFMrIKHNmFWrVVGt2a+OBqO7Wmej0bgtzXvq1Cl0d3cjnU7je9/7njgVdrsdq6urKBaLIgsMANFoVA4SbXSRQYOPf/zjePHFF3H58mV885vflDFidnm/iTY8CLguDQYDvF4vnnjiCZEmNxgMWFhYwI9//GOsrKwglUptuG+rBo3VahVH7l6c7r3AwsKCZAnZ3+jZZ59FPp/Hm2++iXA4LNmaVtSQQCCA/v5+DA0NNfWB2Ag0yNbX1/Hee++Jsci1y/dX56HFYsHRo0dx/Phx5HI5yeQODQ3B7XajWq1KzUIsFpP3X19fR7lcFmeJ+yQpVmtraxs2wtstqGcejbqbN2/in//zfy5y+H19fVhaWkI8HkehUIDT6RQlQp7PG2Xb6UyFQiF8/etfx8jICAYGBrC2tgaHwyEF9WoUm5RdFmi3kgVXz/mdnLNauwG4UyzPOh46l+pXMplEPp8XgZ1CoYAbN24gHA4jm81Kn4hEItFSfpvPwWAwIBQKiW0yOjoq57DVasXx48dx6NAhpFIpLC4uolwuS1NAsk+YYafdo9frxd5UDXeqpe3FmlfHlZlEUuRIK3z66adhMBgwNjbWNG68VgAiWkTHgplEdTxzuRxKpRK6urrw7LPP4tChQ/D5fPB6vXjnnXdw7dq1PcmSabGjGY1W0BYPMTqpem3ZbBbr6+vCSQMg3GR6xeyyCdxRSVhfX8fa2hqi0ah8p4eqGoWFQgGZTEYiPjSKWABOvr2WyvKgXLb7gVYaT72ejaA9dHjdbHpjsVjg9/slStDd3S3SaK0OI1LRIpGILAiOp3o95OGrNIS9QCsawFb+RnU0NjocOF50Mtxud1MxN+dOPp9HNptFIpFALBaTuak6qoy2MHKlPRxa3QcjRAaDYU9FCLYC3gPXVKPRgM/nQygUQjweF3oHDyk2WiJ3mzr9sVgM2WwWhUJBirtbUR/UMduvDgZwN7WA0TTuP3q9XoyHWCx2V90N68CYKqejoMq0aseFkeVQKASv19uUpQXuX+98P4L7D5V6GOmn8w/cjvZFo1EkEokNqZ2tosf7KVvI4BuzYDTGaejxWls5RTqdDk6nU5TxtPVRrcDfka5FOpTqZADNGWA6zpxzLHClUAvXM3A7Q6PX60UNiGetyWQSKVcyCtT9cy/B++TnFgoFLCwsSETYYDAgHo9Lvw8Adzli6nupYOF3IBBAX1+fKGLyDMlmsxI00FL7Wl2nqqi4k6Ahy/fe6PO155f6nXNE7S2Sy+Vkv1MzuFoYDAbJHvn9fgSDQZH6Zq0GqXtut7tJJY7MA55L3C9VJo267tV7fBg2Hvd2BtnpZJHiqLIBtLRY1sVwLam1imp5AdXgOjo6EAgEpCRBFU7aa9y3o3EvSgtBL52HBACh5LCRHgeO6aBcLoelpSUkEgm43W4p8nnllVcQiUTgcDgkGsW/CYfDKBaL8Hq98Hq9QtdgKtnpdIphSB3nUqkkUpHA3Ypa++WwZnZGy51UwYNYjag+9dRT+MxnPgOHw4HOzk4p2qVUolaOUy08HBsba3LcSL+i8eR0OvH1r38dJ06cwJtvvokf//jHu2IMtjJAeRAzYlGpVDZMB6qpaFLyGKHTwm6346//9b+Os2fPypz1+Xxwu93i+FYqFUxNTeHnP/+5dK4uFApiAPEZsR7mxIkTuHHjhjjM2vvgPaqbNqMSO0F9UbvJP0htjU6nk02QPNxAIACr1SoZCd6jwWDA2toa/uIv/kLk+1KplMhHl0olmc9qxoYRM27Aaj3Qw3D6twJmGIA71De/34/Ozk7kcjkpfJ2ensba2hqSyaTUfdF5JW82l8thdXW1iUalOvlqDUi9Xsfq6irGxsawsrIi+xwpd78qYECD9IK+vj6cOHECdru9aVyy2SxisRiSyeRdyi08fFWwkHU79Su7PQfZeI8Ry8XFRfz4xz+W7L2abeB90wkxGAx48skn8ZWvfAWdnZ0i997KsNCebdyzGGhRnQPuH2zMx3o+BpfIBJicnESxWEQsFkMgEAAAXL16Vc6TXC7XRFNRJXxJh95ruWoGMHjv6vlWqVRw69YtrK6uolwuC+VHlU7luUiDlucRn83jjz+O3/iN30AwGMRjjz0Gn88nlLbZ2Vn84Ac/gMFgwNmzZxEIBJDL5aDX60X8odFoSPTZ5XLB6/WiVCqJFPBO4amnngJw51zkPq2eV3QSVBuE997b24u+vj709vYiHA4jn89LJmdqagrvvPOO0NNV0N4KhUL4tV/7NfT09GBgYAChUEj6qFUqFQnkMZMej8cxMzMjzRXZU4zPtFQqNQWzGbRR5zkdx7208dSxrFarQseOxWL4y7/8S+h0OsnKcC/QUvuA2/tEOBwWx0Ov14u8dDAYlNpbtcZoYmICc3Nzdz2DvcKuZzRU+g6VosjjpAQmJwUNuVKphNXVVSwtLWFwcBChUAjlchlXr17F7OwsgDuGj8PhkCxJo9EQihAAMRaZJqexw++MKtDgaaVIADx8qciNshwqVOoGF/CBAwfw8ssvSzOXVqoiBDddNk2kxG9HR4ek4VUuo9Vqxblz5/DSSy9hfX0dP/3pT3fV0eA1qj+nCspmn6sVEWg0Gk2ZAvX9zWYznnrqKfzGb/xGU98Dq9UqEsikNl27dg2RSET0qtmwipk3Lv7h4WGhFGx0nVrng2thJ6IPNBJ2ooCf6XOVN0uHlZsePzObzeIXv/gFbty4IalijqmqVAI0Z4HUeawtXNuPzoa6b/D+bTYbQqEQEokEwuEwSqUSIpGI0OsYOaaDxWej6tjzMFdfp6VMJhIJCciQ8/0w0uK7CdKcbDabFIH29fVJFJOGObn+ag8h/j3XAHAnG7CRwMZm17Hb4Jrgc04kElheXm6ifNCpUK+b9zc0NITnn39ezruNrll7z/w/x9pgMDRFSzmGfA46nU7WMsf9+vXriMVi8Hg88Hg8yGazWFpakr2MdR7avi/q+buX0VZ+Ju9dVeVigIMdzumoqvuW9qylPaIqcQ0MDOAzn/kMfD6fNAFkcTQLmXU6HXp6eqRehWOryhgDkCx7Pp8XIZudwvDwMBqNO/UBjUZD5h2hFVdQ6U7s1O31epFKpVCr1URkJ5/PY2JiQs5OLXQ6HdxuN86dO4eRkREMDQ0hFApJMIpZ8Ubjdv3M+vo6EokEVlZWJGNC5S8+TwYeWW+kBuw4pjT295oyyb2He1ejcVvWOBqNNs2rVlLDBNk4hMFggMfjQU9PD4aGhvD444/DZrOJQubExAReffVVUZl7GOfoAzkaG10sF57FYsHw8DB8Ph9SqRRSqZRUyNvtdszOzsLhcGBmZkbkZN99912YTCZp1hUOhzE/P494PI50Ot30mYyi8t9cLOvr601UHm4c7N7Mjqnc/FTpNF5/o9EQXt9eb4LbAdNtwJ0N4MCBAwiFQhgdHZVNjtGWVuD4fPTRR7h16xYuXrwoBWvBYBAejwfLy8vIZrPyN4VCAW+//TbW1tZw6dKlXSuo1KZp1Z9zs2hlwKspU9JXWKPz5JNPIhgMIh6PIx6PS9dNFjWHw2FJATOdazQaEQ6HEY/HsbCwgHg8jkwmI3Po8ccfx5NPPoloNIrJyUl0dHTA4XDclSXbLh503nFsHtQJVA02v9+PgwcPwu1248qVK3A4HMhkMpJZnJiYwPLysjS3YqaDUq6VSkUitMw2ko5Fw1HlzW80B/YDtFnGRuN21+DFxUWp+aKjRyeC9M1WdUKqgwHcyQhznTudTomOdnR0wOv1ykG7H+oMdhpcs263G8PDw3j66aele7pabErjQi385BgePHgQzz33HMrlMi5fvoxEIiFOCec1x34zNZzdRiaTaYqyMzOq0i14nXT4dTqdiEYkk0lR4Onv72+ixBAMCJAuxT2M0XJ+FqOtrGl0Op04evQoOjo6cPToUQwNDSGfz6OrqwuxWAxzc3NIJpNC/9LpdOjv70e9Xkc0GkU+n5ei1Gq1KpkBLe//QaF9npu9RgvVsVKfA5+9mkVSA24MbPLz6OSZzeamukpmKsvlMmw2G44fPy7SpLOzs4jFYk01WeqcY7aITttO4tatWwAg64m1AarSGOt3Wo0Xa3Wq1epd9sjs7Kz8n6+nPeLz+dDb24uBgQEMDQ2JuIPqwJFW1Wg0sLq6itnZWdlLrVYrnnzySRiNRly7dg3Xr1+XayT1kEa7GthSx1YNcO0WWlG3Go2G7OeqghznV1dXF/r6+iRrw+AlmzPTWeF4h0IhDA0NYXh4WGpb2OmeCq17ncFRsWsZDZ3utqbyY489hqGhIVy7dk3oOIuLizLQpGKwQc61a9eEEqVGdRkFUY2OVhxmdk5lhA+4Iw8bjUYxPT0tuuA0nMib1PKbGbV5EDWMncBGUX3gDg+Um7dOpxPJwJMnT6Krq6uJUqUFN9RSqYS33noL3/zmN5FMJoUz3t/fj66uLumKys/PZrP41re+dU+Z2AfFRotCpZxoX6NGxelAMhLodrvxta99DU8//TRu3bqFsbExuFwujI6OwmazoVQqYWZmRp69zWYDcDvbMTExgdnZWdy6dQtra2siDWkwGPCJT3wCf/AHf4CbN2/ixz/+sXQ03Wjc74XNuL/bwVayYVsFMxo9PT14/PHHkc/n8dZbb6FUKglHm/TEbDaLmZmZph40nZ2dOHHihCjGVatVeL1ehEIhidTx4GVEar8oAm0E7hMqYrGY9FUhv5iUJpvNBofDgUqlIkaeyhVWAxvcnxgkMBqN6O3txde+9jWMjIxgdXUV0WhUIpz7fazuBzqdTmSmT506hS984QtNqkaqAVcqle7KVur1epw+fRr/5J/8E6TTafzH//gfMT4+jtXVVakh0EbZHxbYAVrN7KkS0bzXarUqdFg6GFR1u3LliuzZGzkaxWJR1A1p3IZCIeRyOalxoXKVyWSCw+FAMBjEuXPnxCjs6ekROdbV1VW8//774lynUinpk2UwGDAxMYFYLCZNBHmWqOPN9f6gRpDaf2AzR0NtKqc6cOpreD2qAai1EVgXU61WEY/HxUljt3U1uk7nuFKpwOFw4Nlnn0Uul8PMzAzm5uaEptVqHLLZrDTk3WlD8eLFiy1/TnU3q9Uq64VQHbFUKoW1tTWsr69jcnJSzmaeoWRScOwCgYD0wnnmmWfkXPD5fDL31foFr9cLi8WCcDiMX/7yl3C73ejt7YXf78enP/1p9PX14Q//8A/x2muvNWX++BzUwv1Wxj7txO1iKwFErVKXdnzdbrcU0Kt1eYcOHcKnP/1pLC4u4s/+7M+QTqflfui4srbDZrNhcHAQJ06cwMjICJ588klxcovFIux2+31RE9Vz6UHn3JYdjc2MXbVISZtxSCaTiEaj0iiPhUIqv4yTgzJpfJ3KEWx1o+omQagcV/6bSlSq0aNyXVVPz2KxoKOjQzxhlfv3sLIam30279Fms2FgYAAul0saFKpFogSdAhbhlctl4U+S70h+YL1elyJ6Fv+qY/0wD+btLhibzSbN5LjRBQIBiaIEAgFYLBZp/MjIAQUEjEYjXC6XNO3j5uT3+6WpEF/T29sLANLQj4cP0+Ktrp2bhl6vF5rRfsukMfOVyWSkyVA0Gm1yNFQKJA8iUtwACNfZ6/WKEaNGGLcb3WQXZK7vvZ6TGz0ftf6JdQY0TFwulxgUagpfC3WeqMaRttZMlUVVI7KPMjgnVHpZPp9HIpGQABXpFDQkuAapOsVeTQcOHBDnzuVySTNMm812V4T6YeKxxx5DtVrF+vo64vF4k/HL6+NaIl2FKBQKUsvSSqmIqNVqkn1kII9nntFolOLurq4uGU9mIllYysJVANITgAp7xWJRFNQo50xnnLUO5M7zvU0mkzRPfFBs5Vlqs6RaG6OVcdVoNKRmjzUsNPh43cwCAXeU8hYWFpBOp+WM5npPp9NIp9PI5XJIp9NyFtPpZQBCW6O1G1ADJSoVTL03OkocF71eLwpcNOYZoQcgNRCq+h2dQJ/Ph2AwiK6uLnR3d8Pn8wllj1Ap98wAM6hJuyybzQq1TUs1U51yNcPJayfjgPUQ97P+eWbdbyZZlblV63x4rRxDUvfUeiC1YLxer8NmswkrQ+2Fw/OXtsV2nY2d2he37GgwsqLlu6nRYzUqwQK9d955BxaLpUk3WEtJSqVSotLCgdjKw9NSDbR8PBp2ly5dkkIvKjF5PB40GrfpUfF4XBYBvWSbzYbvfe97IsH5sKOFG40FIyRDQ0P4p//0n2JoaEhSk5x06ntkMhlks1ncvHkT77zzDuLxOK5fvy69RuLxuETBC4UCrl69KsV6O8Hz322odCkWU5lMJvT19eFLX/oSuru7ceTIEfh8PnneFotFDhBmc0gZoANALumJEydgs9lw69YtWK1WfO5zn0N/fz86OzuRSqXgdrvx6U9/GqVSSRrSpVIpBAIB5PN5GV8tHA4HRkZGYDKZMDs7i2g0uq8cjUajIQWiY2NjmJuba8oychP0+XzSnIsbPyOZADA1NQWHw4FTp07B5XJhdXVVpC95iKg0o3sZzS6XCydPnoTFYsH169exsrKyJ+PR6tnwOsll535mNBrR19cntVKdnZ1IJpO4du0aMplMk2KX+l7qFw+hYrGId999F1evXhU6QyQSaXKytNf2sPeu+wEprWwIl0wmcf36dfzsZz+D3+/H8ePHYTQa8cEHH2B2dhZGoxEvv/wy1tbWRGXwt3/7t/GZz3ymSTmut7e36fDO5XLSt0g1NLXPdi/G8L/8l/+CQqGAP/zDP8QPfvADyT7wmvR6vUhVHjt2DL/2a7+GRqOBt956CysrKxgaGsLg4CB8Pp9IlmvBvT+Xy4nCXnd3N06fPo1YLCbO72c/+1k8//zzUuNoMpmkVwblq7mP2Ww2PPfcczh48CCy2awYfcx48PmlUikxILm/Hjx4EJ2dnZiamsLly5cfOPu6FYO8VRZS+3vgzlnC9/T7/fjYxz4Gu92O8+fPY3Z2VnqFMPpvNBqxtLSESCSCS5cuoVQqIRAI4KmnnpKGcjqdDtFoVJrXsU9HNpuVLAjvgU4do967CXXec+6trKyIQa3Sdmw2G06ePIlgMIjZ2VnMzc2hq6sLBw8ehNFoxOTkJKLRqNTBkgJps9lw6tQpHDlyBKOjozh37pzYZCpI2yK9jqwX9s9gPybK79+4cUMoc2rPJd6TyWQSx8NkMuGFF17AqVOncOnSJbzxxhv35eTabDY5AzcqztcGwdWxVpXe6FTRQa9UKhgfH0c6nYbZbIbb7RabhnU+9XpdWB3BYBBHjx6F1+uVayI91OFwYHBwUIrmtdfRKuOiOttqIPB+98FtZzS0mxcvgl/qRsF0IgeSBVUbRfC2cy0qvUD9rvJbeXiQc8jotHoPalEg35sdKdWU2n6IeG0Ene62Wsjo6ChGRkbE4dPqkjcaDUmPr62tYWpqCrFYDNevX5cImhoVqNVqwv/ej+D9tUqTq89Tr78tNdvb24uenh7ZsJxOpzjKjKxzw7HZbOKoMUrFCBx1vd1uNw4ePIiDBw9KFIrc00KhgJmZGYlmaWVcteBGrMpD7ieoqXJG4gA0ObLMHPHf3BAdDge8Xq9EyKiXzmZzsVis6X22E70jh1eNJu4mtHzeVvuCWoCvOlterxd+vx/d3d2wWCxYWloCcKcrsaowoqUQqFHGSCQiEeBarSZOSqs9ej/vW5uB906DlhLAiUQCJpMJxWIRJpMJyWQSa2tr6OrqEipRR0cHDAYDDhw4gFOnTjUJO7hcLon8MQAG7H1j1lY4ePAg8vm8SL+qwRIanFR+Ip0MgKgwkpet1j3wnvj/crmMdDqNbDbbdK+k9JHm0tnZiQMHDggFSJ2TdGJUIy4YDMJoNCIej8NsNkumHGjOUnKPZISVPYeoZvWgjsZW53ur12kNLi11hPfJcQLu1ImqgiMc52QyiYWFBeRyOfT19cm9G41GyWKQWcBCXW3NgBrN3kvwnmnIqpky1jxSbpYS9yptjPU4rC0glclms0nAJRAISCZNCy19il/cV1lczjFLpVJ3ZUFp/2nHVK/Xw+PxIBQKCW3+fuxRVRxnK+OpBQNqXNcARJ2VtghVHLmm1eyMer9cp8z60FGkc+pwOKQmTXtOtJr32mtXX3s/Z8qWT2Ztek29KFJL1G7G/B2pO/Q0tenJ7UKnu83ZtdlsolHNYl6DwYDx8XFMT0/LBghADmSmbZkuY3rK4XDIYRQOh/GDH/wARqMR8/Pz+yai3Ao6nQ4DAwM4fPgwjh8/Ljr8au8SgpvGK6+8gjfffBORSARzc3MS/XvUCkmtViuGh4dht9uxvLyMcDjc9HveCzWlPR4P+vr6xNGgioq6mQEQZSp1wXJxsgA8kUjIa5xOp9RiqOlPAFL4DECiO6rggHqI5fN5TE9Py6YJPPxIdKsNR80y0PAFIIoruVwOs7OzsFqtOHr0KOx2O86dO4cjR440OWN+v186wLpcLsRiMeh0OuTzeeTz+ZYKJa1AxRu9Xi8c990Co79Wq1Wyfyo456jzrhoLPHxHRkbw1/7aX0Mmk8GBAwcQi8Xw05/+FGNjY3A6naLmNTIyAovFgomJCSwtLaFWqyGRSEh/FYvFgkAgAL/fLz1x2P+GRcX7hRJ0P6Cxxqhko9FAKBTC2bNnodPpEA6HZS+32Wzw+/0YGhpCf38/+vr6UK/XcerUKTkHeBacPn0aAwMDSCQSuHHjRpNSGg1qngXA3vYj+Vf/6l+hWq1ibGxMlO4qlQo6OzvxN/7G38DAwADeeOMNnD9/HleuXJHi7ampKWQyGZH/9fl80pCMmRxGzJPJpAirfPjhh1KozTnDTBK59zSqua+p/TlYO2Sz2XDkyBHkcjm8/vrrOH/+vAQdarWaUJFVaWeu8evXr2N+fl4it7sRLNDutRtBG70F7uzB/DutIct1ns1mMTc3B71eL6I12WwWCwsLWF9fRzqdhtPpxMjICAYHB4XaxwwTVZRU2vLDsD02Gh86iRyjcrmMmzdvYm5uDplMRuhTV65cgdVqRSAQQCgUaqoRZM+L/v5+eL1e6Ye20XWQVcH5UavV0NPTI42cGWRRRTacTid6e3uh0+mwvLwsr1OvXafT4fz585iZmcHKysqG/T3uBRrxmznHWlqe9uf8+2KxCIPBgEQigUKhgKNHj+Lll1/GysqKZBrVwAMdvZMnT8LlcqFSqeDChQsIBAIYGhpCuVzG1NQUkskklpeXm54BAFGM5HlLh2yjc2Oj+9gqtryq1TSU6gFxI2daX3UyVEdDWzB8v44GcKeIJhAI4ODBg7Db7dLlmilJ4M6gMqLCyZbP5xGLxeRhsQaBGtUffvjhXZ+5Xw/szs5OnDp1SqJPnDCtiter1SouXryIb33rW5JGfFRhNpvlUM1ms+JoaB1Zbm52ux2BQEB6P/DgpGPBzZ0GCdPrKi+VnFBVktFqtQqVQBuVZ+EjAKTT6btSlqwRYqpzdXUVQDO//2HMu40OOHWzUV+jRooYReno6MBjjz2Grq4uvPjii3j66aeb9g0WSfJwtVgs0tNmO8ILxWIRCwsL93Wf24XRaERnZyfcbrdQHlqBex0jnMzusJD+zJkzKBQK8Pl8iEQiuHz5MsbHx6XoNhQK4dy5c3C5XMjlclhbW5PicRrCdNYYDbbZbMjlck3z81F2NLj+yM1mpvnw4cPIZrO4dOkS0uk0KpWKCGKwV9C5c+eEKqHuhwaDASMjI8hkMnj33XclCgtA9gODwdBUOLmX4/fnf/7nACB0Ee4BPp8Pn//85/HYY49hfn4er732GrLZrPRaYI0OaYjVahUdHR2w2WxyT/F4HNFoFNlsVqLpnHccH7vdjuHhYTgcDtTrdWmup44PKRuNRkOi1I1GA3a7HZVKBT//+c+FVtrd3S1iK+TZcx/kvkgHh474ThjXWttCdTS2gs2496ojoq4xZtzU1zOgCQCrq6viRLlcLikiZ3aD2U3tZ6nXv5V7vR+0os6oP+fv1PVQrVZF1IeZtGKxiNnZWdjtdvT392NwcFAy9FzPRqMRgUBA6N2bnTUMNqyvryMWi6Fer4vcPrMarKnk2c09QqfTScCHkuKcZ41GA7du3Xpg8YGt9jLZ6DP4c1JsWZdZLpfh9/tx9uxZTE1N4bXXXkMymZTgJ+eDzWbDyMgIfD4fKpUKJicnhSrF3jbRaFTGDkCTk8LANIPum13vg86xbYcPaJxRQxu4I4vGTZsbEItjTSaTSNs+iGdEp2Z0dBRHjhyB3+/H4OCgRKx1Oh0mJiZELlcrT6d+rkr30i7kjegQ+wnc8Hw+H0ZHRxEMBlEoFKTJIVNx3AQjkQgSiQTy+fyO9VV4mGD2KZvNIpPJALjz3KguRT15ShBy7mozPWpkhMW1lUpFCpdJRVtfX0cqlUKlUsHzzz8vEqOt5PF0Op3QAjY6QDfKIj0s41CNUtJYJl2MGyDXlTbDSWeOUaVgMIhDhw6hs7NTRAn4WnUNdnd3Sx8S9eAi93m31MzuB9VqVYw1lTpGiqXa1Aq4LRTw+OOPw+Px4ODBg1IEmUwmsb6+jg8++ACRSAQmkwnHjh2TRoh6vR7Xr1+HwWBAJBJpOuRVCgtrC9SeBuTg3itzrEav9iPI46eharfbYbFYxLhYXFyUzB8AqVUxGo1YX1+XgmbSizgmNGjVc4wGx/008dtJqIW3PLtqtdtN4q5evYp8Po+lpSVUq1X4fD4cPXpURBgMBoMUY9Ogo2FSLpexvLwsGRwG1RwOB3p6ekTAgfM0GAyip6dHBBtyuVxTt3uem8VisSmAwn3UaDTK/syxp+Oi0pqBZsN9p9b6g+6pGxm/uVwON2/elKAI90Cuo43ou8CdjACVL4PBIJxOJ6rVqtQRainAPLtpiO4WNrJ91AwA/6/94t9zvfr9fhFX8Xg86OjogN/vR6PREIpZf3+/NMJVP0cFHRMGfyk+wsxjMBhEvV5HMBgUinc6nYbRaMTa2pqsd7vd3mSbau09lZq6m2DQCbiT8daOM3BnDUxOTuKnP/0pwuGwKFzSzub6y2azmJqaEgq31+tFJpORdgNU/KI0MpUeAUhNn8oc4DNVHWn15w+CbTsaLMphcTCLvtULUYtaurq6YLPZJMX2IBdNusvzzz+PL37xi/B6vejp6ZF0bqVSwcLCAhYWFqSZlVYSVz2s1Um3WXp1owzBwwSvf2BgAC+88AJ0Op0sNqoMcPPLZrMYHx/H2tqaqLYA2PNOrDuJYrGIiYkJoZKoMBqN6OnpEUoTez+oHGQVlUpFNOAXFxcRj8dF2Sefz0vPB3bsfv755/Hbv/3bEhVo5WiwiQ4jhQRft1mq9kHTlPcLcqbNZrOkVFnkaDAYkE6nxZhVD1kAQvvp6uqSpkvPPPOMGC1aSgSjXEeOHMHw8DA6OjowOTkJg8Eg3cPp6O0XsMBfSxnzer0A0FQ3UavV0NfXh9/5nd9BT0+PUJzYjPTmzZv41re+hWg0isceewwvvfSSKKnE43G8+eabQidR+bnM0hkMBiwtLYmcpGrs3GvecD/jYf4wsVE0lUEqi8UiXGq73Y5cLof19XWMjY0hHo9jYGAAPp8P6XQac3NzqFQqiEQiAIBPfOITYpCQXsEoKqP9nGM0RvhsH8a+SCqG2mxMp7vdLfinP/0p/H4/xsbGUC6XEQwG8fnPfx6BQAB9fX1wOp0YHx/H+Pi4BPfMZrMUnI6Pj+OnP/2pdGxWewclk0lEIhF0dnbi7Nmz6Ovrw+DgIDo7O2UfJDOB2TM6IBMTE9JvCLhNZaSK1NzcnGTfDAZDU58TUoPoJNHR2w1shxaj2gJaBkYikcCbb74ptgbnC7HZnOGcmpubQywWw8GDByXIQnqvavhxPd+rAHwn5inPw1YOttbRUGtfVdYK59OJEyfgcrlkXY6MjODYsWNN9+LxeORMVGm42vGqVqsoFApYWlrC4uKizBmn04nu7m7Zey0Wi8jrhsNhXLhwAaVSCX6/H16vVzrQq/RI2k9aCendgslkkn4rrDnTgmugWq3i/fffx9jYmPS7Uecaxz2fzyMSicBqtYpAxszMDM6fPw+TyYTTp09L88z5+fmmACFpv6rdy3XC80V91g96Dm/b0aBnrupJq9EJXihTYxw8HpD8m+0aUzTYXC4XvF4vOjo64Ha7hbYC3D6c2Hpdp9PJgcM0repcqJ6sOqBNg6N0YX3YfHkVvH4aa4VCQa6VBXVMJzJdvbS0hJWVFYlA7af7uR/QSFKjQA6HQ6TyqBTF13KxkA4FQIxZ8mvz+TyWl5dFnSGbzTZJuHKD4sGwkZMB3I5+RyIRxGIxZDKZDSPIakRP+0z2ItLS6rMY1eCc4jWqRZA8NHjI0NEIBoPo7++H3+9HR0eHGD2EGgXTjqfX65W5vF+j7doNV92EtXsI5Y0p+8vO3blcDsvLy6LIk8/nkc1mYTAYJEMWCASkqJaHg2oA0dhRi5lJ0eIecC/u8H4Y381oBVwPpEZVKhWsrq4imUzC7XZLcbfNZpPiUwZW2IupVqshm80Kz5l0jEQi0WT4qtfysMZFGwgjSDVikzv+jnOJ/VgYpSTdzmKxIB6Pyx6mngkApFs134t1IcViEdFoVAx/rbymljappY1yTFX6V6tOx6qDzCL9vdrvNoI6B7QUVlXlR/v6rYIZcgBS20pVPioQqY7xXji96p682TmlpaBp5wINeWa2mW3jOKo9qVRbUAXnJzvOMwvGfY9iIrwONbDDn9MusNvt8Hg8ku1ldo8O1V7ugfd6llz3vCYGQNS5oH1OtMUBIJVKIRqNIh6PI5lMwmw2IxaLifIbkwKbOZK7iW05Go1GQ4yvVhx/DpbL5cLBgweh1+sxOzsrXFoWhzF1tNkDVwdAp7utqnTo0CEpdmFDInVD1uv1OHr0KOr1OiYnJ0VWj41wWDRJ4wi4nUKiXrH6IPT6O1rLjDLuh4MZuH1tPGAjkQj+8i//Et3d3XjmmWfgdrul4I8H6ezsLL75zW9iZmYG8Xh8xxr/cAN5WBFAGly8lqNHj+Jv/s2/CQB4/fXXm7j7qVRKFiAjcgsLC5iamsLy8jJee+01yWSQ982iSCoCHT16FAMDA0JTYwagVQFjKpXCn/7pn+LSpUuYn59v4pWqY0WniLQD1ThUu6zuJlQDleuATrvBYECxWITVasWhQ4fQ0dGBmzdvSubM5/PBbrfj1KlT6O/vlyZM7ObMyCrQ3OOGh0KpVJIaDTZtunTpkhRF7nfQaAXuSCpz75qZmcF/+k//SbjtWqe0Xq/D7XZjbGwMFy5cwPPPP48vfelLMBgMeOGFF1AoFPDTn/4UH374oQRqGo2GUAXVCCSfIfvBcL63AtfrftnPWoEOAgCEQiEMDg5idXUV3/jGN9DV1YUvfOELcLvd4siHQiH09/dLUy82o8vlcrh06RK+//3vC3WA0pGLi4t3ybU/zHHh2ud8oWHE35ESxT3+tddek9caDAZYrVaYzWbE43HcunUL1WoVq6uryGaz8t5cj3a7HSMjI+js7MTi4iJu3rwJvV6PiYkJTE9PI5VKIZfL4ezZs/jqV78qSn0MZtXrdanDqNfrElQ0Go1IJpMwGo04ePAg6vU6FhcXhWPOGg/OXRqFjz/+OH7rt35LAhm7CdW2aEV3Yn8vioWoDr02A7fduULbw+v1YmRkRLIcdrsdqVQKqVRK6IGM6O8mbQq4MwYq3U4VQ1CvW6Uaqo4JKT0MBHd2diIQCMBoNIoELTP83MeAu2lbDL5Eo1HMzs42ZdVnZmawtLQEj8cj8+jGjRsoFApwOBxwOBzynMxmM44ePYqDBw+KM766uoq33noLyWSySZ1UtSN2C6oKW6sssnbf4TgDd2j7ajG4GpSo1Wq4ePEiZmdnUSwW5XxYXl6WTJw2O8d1rAbbVXtcHZ9Wtvl25/22Mxoq322jh8OMBl9fKBSEy8yNhTelVXXg+2oPZXZaZpSU8ngqdDqdqAulUilRYuHAkAvJa1G5pVpes06nk2YxzIjsl4OZKWdGoKLRKBwOh8iJ0sFiwW0kEsHs7CxmZmZ2/B60UY69gHZzoqpMIBAQdaMPP/ywaUOjIZ/L5WShJhIJLC8vY3Z2FuPj4xLFq1arcLlc8Pl88lk0+n0+HxwOhxz8G913pVLB4uIibt26JU5JqzofzslW2CvKnhqtIji/VLhcLgSDQSwvL8uBwQhWR0cHOjs70dPTg6GhoZb3pFIm1HQ9G4c5nU6RGd4OT34j+s1egBFyLXS620o0t27davo5U/UOhwO9vb2iMhaNRpHL5aS+ipRAt9vdlDHmoa7NIgN3CnatVqvUkGwWQduv4H1yX6akNOmwlKoOhULyN06nU6iMbPxaKpVErWtiYgKZTEaie+FweEtFkHsJNcjFrB7BQ5/1j9VqVXoccC6wCRr3f9ZmZDIZYQHwbCW1MxgMIpvNivJiMplEtVrF8vIyYrEYBgYGZE4xOECQZcAsC6+RdCBKh/J33APV++LPfD4fjhw5sieOBtBcaK197qoRR3nljWyd7Z59qgIds+4ejwc+n0/GTqfTScZ4L6LNanBEe06pP1drdLTXxjGgI6tSPikSxGAIX98qu8WMTz6fRzKZbJLXrdfrknlT2RqU4LdYLGJQk3rJ89rtdosDqZ4texVcoAO7nddz3nHdqSwi9XobjYYESQk1cHmvDJU2qK8dm53AtvtoqMa4SitSJ04qlRKJvgMHDuD48eNSgJfJZLC4uCieFyOa1PWmVx0IBKR1ejqdhtvtRldXF7q6uuByue4q4uF1Ua9/dnYWa2triEajojhA+ot6P9qiVh7WlATU6lvvB+j1eulsfeTIETzzzDMolUr4i7/4C2lAyCY5er1eOrNvBNVZaDUhgY0L7PY6m0Fjl9SkSqWCT37yk3jmmWfg8XikKdSnPvUpfPzjH5dnmsvl8Oabb8JgMODEiRPo7OzEhx9+iFdffRWJRELmCTcwFtb7fD6cPXsWgUAAZ86cwcGDB9HR0QGPx9PU8ZpgEZbRaMS5c+fg8/lw4cIFXLp0qaVjwsY66hpSN7+dHFvts6RjSlDJy+Vyoa+vD319fcJ9bzQakvomJ5Sp63K5jMHBQTz11FPo7u6WKCCNFrfbLT1LtMpcpK5NTEzge9/7HtbX17GysrLvI+6bQXsIqKCTUK/XJeLEGrfx8XH8r//1v8RxrtfrGBsbk5oYtYkhgyUmk0mCObVaTRpOqr01HqVx5L0zAur3+3HmzBk8+eST0lTObrejXC4jHA4jmUzKOUJ1Ghadcn53dHTg0KFDiMVimJycbIrwaw2ehwk1QsnnTUc8mUyiXq8LRTGdTotKXUdHB8xmMyKRCNbW1oQ1QGODwhaFQkFqVAwGgzhkKysruHbtWtP+RNZBtXq7IzubptEBqtfrIu+dTqfx1ltvYXFxEdeuXZO/X15eFgNLlZrnZ1gsFvy1v/bXcPjwYVSrVfzX//pfAQB/9Ed/tOtjrZ71HHNtFFddq63Owe2sK9o2R48excmTJ2EymfD666+LAT80NCRSrqTJaZU69wKq4cm1Y7FYJPDLbFilUsHS0pLQFEnd4zylwEdXVxf6+/vhdDrhcrkk+8WIulbhi0XlDLRQIpiKj8ViEV6vF88++yysViuy2SyKxaLUJ1WrVQwNDUGn02Fqagrz8/MyX+PxuPT1UAPcO1Wnxj0HuCMMshNQ9yp+1waaVHtczYSo9rp6pvI9qBimUvW07AYt7uc8uW/RarWgUL0Yne5OUbLX68WTTz6JQ4cOSVfI9fV1GI3Gu6RCGWmmNxwKhRAIBBCNRlGr1eB2u0X6kR2bW4G8U6vVimg0ivX1dbkuDpzKbeOkVyk4LBhiVEydQPsBOp1O+PAHDhzAY489homJCfyf//N/sLi4iHw+LwV6DodD6g02wr0oUPdyNvYKpND19PSgUqkglUqh0Wjg6aefxu///u9jdXUVV65cgdFoxDPPPIOuri5xXD/44AP863/9ryWtWCqVcPXqVbz11lstIw1Ub+no6MCpU6cwPDyM48ePY3BwUOZDKwOFjobBYMDp06fR19eH9fV1/PKXv2y5aFspYmgjCvdjCLV6Zlqjk9FRrgeTyYTu7m4Eg0GcPHkSJ06cwOrqqhiyrEmhyhvlaSuVCnp6eqRDt16vF0pRqVSCxWJpcjTU+yOXfm5uDq+88oooKe03bDdrstHraNAwaqdienoaMzMzcqCra1Lds7hfkd5XLBaF06tVYHvUwDnJLEYwGMSJEydw9uxZGbdMJoPJyUkkEglkMhkUCgUJrtDw4RqlAh0j81NTU011L/sNaiSThmalUpH9u6+vD11dXZifn8eNGzdQr9eFShKNRrG6uip7hkqRYKExI+Y0JFhQOjU1JRFfVf6SKlVqBJ5nKKmj7Mlx4cIFoRGWy2URfwEgtBt1rzWbzTh79ixeeukl/OAHP8Af//Efo1gs7rqjoUbuef7TAVINMm0BrvqMtru+aC8NDw/jhRdewOTkJF599VXo9Xo899xz6O7ulk7jdAr30sloRWWio0G5YwBSiE01qEwmI881n89L3woqPx05ckTUpdTMBqFmLxuNhgQHSOHK5/NYXV0VGiQDV6dPn4bP52uik7799tuS7azX67h+/TrW19flWbNWQxug3qm9gPNpJ99TdRy0P9d+NrNvhDZLpaVCcbxtNpvsD2qwn7bMTuC+reeNotnq/2u1GsLhsNAsmDYcHR1FuVzG1atXUa1WMTg4KHxFpsp6e3vh9XpRKpWwsrICo9GI7u5uDA4OSvW+FvV6HTMzM5iZmcH4+Lhsqmp0WHvN6kHO6+ffqT/bb8YPi0inp6fx1ltvIZfLYXR0FD09PZiZmUEkEkF3d7c0BWPEvhW0xqgqxaYt4mvlWO6VUcM0bDQahdFoRH9/P4xGIyKRCH72s5/JomINhl6vRz6fF+rS2bNnRUP+woULWFpaalmADUAkcX0+H/x+P3w+n0RaWhWAcxGnUimR3rx8+TLC4TCWlpbuKrKjsagtzFdf06oOajtjda+fqYWJNGTZfIm1KvV6XSIeiUQC8XgcRqNRKGrAbec+FApJZJCFdyx25KbFLGaxWBTqCrOOt27daop27jfsxXWpn6EaOdqsMY08Hpx8htpD/FHMCnH/8Xq9OHnyJAKBgGj2OxwOERdwOp1ijLBuIRAIoFQqiQpYMBgEACm+X19fb6JP7Tf4fD7JAKh6+Y1GQ7KtkUgEtVoNqVRKjJpisdj0HUDTHsL35O99Pp9Ic5Oqx8gyx4VnYCQSwfj4uGTPKSMPAMlkEouLiwiHw5IxZwZGdYzVawHuSBdTgpwOi9/v33KjzgcFI+tDQ0PweDyIx+NIJBKw2Wzo7OwEAGn4pqpBqdKfW11bOt0dqnNHRwe6u7vRaDTEKCc9srOzE6dPn0YikcD09LSc8btdo6HOM5WWaTKZRNgjm81KY7e1tTVpfszMKiPjbDhH9cJUKoXJyUlpLsogivYM1QZyuGbZEsFqtcq6TaVSmJ6eRjwel/3A6/Xiqaeekr2RdHeyUei4q8b2Tu+NrQq3dxN0Cmj38BmqAXX17GhlxzKQoBaLq5m9jT4X2N6Z+ECOhlbiUvWKGUW5du2aLJpSqYSnnnoK/+gf/SOZONlsFmfOnMGzzz6LfD6PmZkZ0fimbvqNGzdgNpvx2GOPYXR0FIFAYMPrefPNN/Gtb30LsVjsLsOa0UReH3B305VarSZ/p0Y49tPBVK/fVlYxGo14/fXX8eqrr+LIkSP4+3//76OjowPf//73ceXKFZw7dw6f//znMTU1hatXr0pDtFbOoRoFs1gscugxKq1mPdS03W47GtpJnU6nkcvlEAgE8JnPfAZdXV24cOECvv3tb+P06dP4zd/8TXg8HunjEolEMD8/D6fTib/zd/4O0uk0/sW/+Bd444035PDWfp5er4fH48HAwAAOHDiAAwcOYGhoSHTlW4GFm4uLi3j99dcRDofx85//HPPz81Iox9dxszUajU2HmPZatLrqD4pWNB51PZCOkk6n0d/fLyo3TqcTjUZDIkTnzp3DJz7xCdjtdgSDQVitVvT390vWkMXzXq9X+Oa1Wg3xeBwzMzNYX1/Ha6+9hpWVFVHJoAznTtzXow51v9HOf/XAIK1TXbt8/cPqBfGgYEZjYGAAX/7yl9HR0SER88OHD+P48eOw2WwIBAIol8twOBwolUpiuLLmiYdwrXa7/83FixcRjUaxsrIiBhOxX8ZpeHgY9Xodq6urkhlgJDIWi0Gnu907hVF4rstUKiX7j5YqQWOfEfJQKITh4WH09PQIf72jowNGo7GpDwuDBpOTk/jBD36A3t7eJtlci8WCxcVF/Pmf/7lkUoA7VFBeA3C3+IDZbEZnZ6dEy1mjMTIysidGNdePxWLBs88+i0OHDmFiYgITExMYHBzEyy+/DJ1Oh+9+97sYHx9HPB5HJBJpMuy2Y6zSkXI6nRgaGsJjjz2Go0eP4uzZs8hms7hy5Qqi0SiOHTuGs2fPSnaXNUlq/7HdgFovp9p0DocDTz75JIaHhzE/P4+VlRUsLS3h4sWL4rSaTCb4/X6hM8/OzsJoNGJ0dBRutxtLS0u4evUqhoaG0NfXBwCiFKruVwzE0UaLRCK4cuWKUKVcLpfUnS4vL+ONN96Ay+WSc3lgYADHjx9HJBJpsnVYh8Vn1soR2CnqJNU+OX67BV4vA8Iqw4L262Z0P3XcKWOvQmvXq9CWD2z1Prddo8E3Vykd2t+p/yaNhLxDtciJXr7b7RadeTYmYbqHPHgWUWqVpoDbGxkHLB6PY21tTZSVuFFvNiDatOFWosF7CRqCLCJVi/P4LOjV+/1+hEIhdHV1IRgMoqOjAz6fD6FQCIlEQtRE1NQ66w3oDFJtg+O3XzjMwJ3MgdoDJJfLifoM0CxjTKONUVLgjgKEtsiW40G6RW9vL7q6uoRGsBF9jqnbdDqN9fV1rK2tYW1tDfF4HKlU6i75x+1gN+cd545a3EcOLgvtyuWyZBAZNWUE2el0Njl1HGuuX44XlVQSiYTQKmOxmDSR5O/3W9bwYaAVhUG7z6r7X6u0+n5ar9sFI+FqRE6N2AF3zg4AEo13OBxCqSXFT1VuUY2N/TrPtDVcPBuZaWTAQu2ozDW3FU44DWyVgkYZUVUQRWuIqT9THV5ml0lrUdUbATTtKyqzQJUnzWQyUkO4289Ga6fo9fom24NzJxQKSS+mVColDiuVqAA0qTduds0M3HV1dclZTNlXZntZS0M7R5sRup8I8oNADbAyq0J6ZqlUEgoeHXpeH6WRWQQO3GloSnoa/5ZzWaUgNxoNkbRNJBLiWKhF3qz1VevYSqWSdLlWn4XKSNmr8dtLO5G2m6o8x4ChVqxGy5pQx1y1ffjajZxo7d9uFVt2NNgATqvrDuCuaLca5aZRTP5nKpXChx9+KJGM/v5+dHZ2wufzQa+/3Sm4Wq1ifn4e8XgcTqdTlKbYiZSKVkQ+n8eVK1ewtraGmzdvYn19HfV6XZwUDrx6zdpJqGY5VA9/PxxKNpsNdrsdfX19+PjHPw6r1So9Mfr7+zE0NISenh50dnbC5XLhYx/7GE6ePCl0n76+Pqlh+O53v4v3339fNrVQKIQvf/nL6O3txcWLF3H9+nU5iGigczPUZnX2Ymw2msyFQgFjY2OYm5vDysqKPFfyRRl9stlscLlcsNvtTVzFVsppOp1OXvvMM8/gd37nd9DR0YH+/v4NZWw5Lu+//z7ee+89qRPJZrNIJpNNzo664ZXL5XsaB3ulOsXrslqtePLJJzEwMIBUKoX33nsPvb29eOGFF1CtVnHr1i2R6vX7/UKvI12CtUBs8OV2u9FoNPDmm2/io48+gtvtRigUEocsGo0ilUrdZei0ccc40zqpVPoxGAxNHcpbZSkfRdDhnJ+fx+uvv45QKITnn39euN48X3gGsMAUuEO7Im2S0dGOjg4cO3YM4XAYiUSiJcVoP2B6ehoAxBg/fPgwnnvuOeRyOfzsZz9DOBzG4cOHMTIygnA4jKtXr0otGQ1T7f3wbGYxN9fx0tKS9CRZWloSCUy+lrWSXV1dOHPmDEKhELxer8iKlkolJJNJzM3NIRKJSKEthVd4Hzqd7q4gjV6vl4Dij370I7z77ruIRCJYXl7edUdDpbCaTCb09PRgeHgYt27dkjHo7++XIuhoNCoy6GazGX6/H9VqFT/72c8wNjYmvZhaGWbMzvX19eHv/t2/i2PHjuHAgQNiEBqNRuTzeczPz2NsbAypVEoy9uvr6yKruxXD7kGEatTiYXV8UqkUfvSjH4n9xnulk8DziQ4rz1X2CyqVSjh48CCGh4fldazTYDbS6/XKc6lWq/jggw9w6dIl3Lx5E9PT01J0bjQa0dvbi4MHD2J0dBSf/vSnYTabJag8NjaGcDgs1859UauU1moc99MesBVwXXm9XnzqU59CMBgUCm0sFsPCwgJyuRxWV1ebaKKtMjmqQ8gmiptJKt/vvrllR0ONWPIi+V2NHmsfKhcUX1MqlRAOh6U41OPxSMSYTkm9XhcjhFkPs9ksBo0axaPRtr6+jqWlJcTjcaFuWCyWuwxJNbKiQnWaVCWE/QA2NOvo6MDo6KgcGI1GAz09PTh27Jj0M7BYLCL9yI3A6XTi+PHj6OnpwXvvvSfPjM2CRkdHMTIygkgkIopgqmPGQ/tekRtgbxYt+ZaRSEQ41ypVgMYI758OpzaipUZjgGZ50J6eHjz22GOw2+0SuVHBOUTKwvLyMq5du4ZIJIKlpSWJ/KivVcFDfbPxUp3fvYDRaEQwGERvby/S6TRWVlakIBeABAeoCsSoMp0t8sDZfI4O6tTUFM6fP4++vj4YjUbkcjmJgHKcHrXNfrfBualm52hI03BTKZ6/KuPH9ZtOp7GwsCBSqYFAQCKljBIDd/YbBkfUMePvme0tFAp70gX4fkGdfZ53Ho8Hhw8fRjKZlEAJ5du5R2v7P7UC5w3PcBbOT05OIhwOi+gJnQzumzwfKMzCegoGFMvlstS8pdNpaQhIqJFS7bhzv5ifn8fCwoIwHnZ7Hmv3ezYBNhgMQjlxOp0S+Ozr65OoscViQWdnJ8rlMi5fvoypqSm5l1ZRYEqiezwePPbYY3jyySeb1jK/0uk0otGoNNVVsxlagZB73dP9oBWNqNG4XS87OzsLAOIc8Xfq9Wv7jNBpYOH28PAwyuUyVldX5TnbbDapMVJpTSsrKxgfHxfKWLValfOkt7cXHR0d0lfHYDCI6lwsFsP09LR0C+f1qHK6j/Ie2WoO0Int7e2VWlTWV5pMJsRiMVHZ4v1vJDDAwCz/vRnuZxy37GiQe6Yt8OLPuPmbzWYpMGEtAb1hpuLW19eRz+cRCoVkI+vo6JD3qtVqwrn1er3w+XxwOp2SmuPmygm2vr6Oy5cvY35+XrxaRl3Ua91oQQF3og90XPZLip3efyaTwfr6Oq5duyZSv8PDw+jv78fAwIBQqtQJQ8esWq02GYfk9tntduh0Oty6dQvJZBJTU1MiGUsjhtkUNl0k9PrbzXmoEEN1q6WlpZZ9BXYK6nVTxtNgMEjWi6lYLqx8Pi98zVqtJlmcwcFB5HI5pFIpqUlhB2JmQYDWG1QulxNa1KVLl7C+vo4PP/wQExMTck2qNKHq0KjXpm7Y6ufQUNrtjIZKRyH98PLly1haWpLnn0wmcfHiRVitVlHfGhkZAQAp5q5Wq1L8F4vFsLi4KNSMYrGIsbExaRwWjUabGompTsajfBDsNOgsq04zDwxKgXOdqUaAWsz5KIJrolQqYW1tDTqdTpSkVNoQ93jWqaiqSAwAsMB3YmIC58+fRzweF777fjQ8mKXh2TU7O4uf/exnKJVKyGQyMBgMIn+azWaFIkblNy3diUY+9xFK2k5PT0sTtOHhYTFySYXieg6FQujs7ERvb69kJ6mKRFU50qFbzTv1HFaz4exxwD2cTg7ls3cLNLRUyk44HMb09DSWl5elXiyfzwuF2Gw2Y2BgQDLaTqcTtVoNX/3qV3H27FlkMhkkEgkxrOk8ra2twefzob+/Xwqq9Xq91KNZLBbp7eDz+dDb2yvSsKrjqGWIbHRfOzU+G9FmGACg7DQAUbfU2lVkrpjNZnz00UdYW1sTB4B9UtiklnNoenoaiUQCV69eFdnv48ePA4DM3VOnTuHw4cPo6uqSzBmf59DQEPx+P9bW1nDhwgXJppw4cQJra2tYXl6WwnrVjlEdpv0MdYy5novFooyXx+OB3W6XBtWcwwDQ3d0Nv9+PTCaDtbU1cQy1NDOe+buhdrZlR6OVGkSrFKnL5ZLNiI6GWuRZLBaxtraGUqmEAwcOoLe3F8FgEF6vt0l7nwuRzgYbCqmp4nQ6jdnZWSwvL+PKlSuYnZ0VOduNFHu0kWzeA1PLNLI3a9KzV+Dns1cBHY1gMIhjx47h+PHj6OjokA6cqkY60Oxo8Pfk8rHeAwAmJyextLSE6elpkaWjUR4IBGCz2cRwJBhdI8c1FAohGo0iEonsuqNB3nI0GkW5XBbqHSNTauQll8shGo0KzcdgMCAUCuHAgQNYWVlBLpeD3W5Hf3+/CBAYDAa4XK67HAL+O5vNYmlpCYuLi/izP/szTE5OIhaLIZlMttz0tRxzAE2ZQbUQjteoptd3C9yw+LwLhQKuXr0Ks9mMQCCAzs5OJJNJXLp0CR6PBx//+Mdx4MABmY+5XA6zs7PI5XISZQ+Hw5iZmUEqlcLNmzeFW877ZQM7LUe0jWZwXFoJL7BIn/OS2dvNIlYbYa/531sBA1LRaFRoNpTrVrPN9XpdsmNer1cMIGbY4vE4lpeXMTk5iYsXL0q/mv0KFneTijI/P4/l5eWmDMPi4iKmp6fhcDgky0DDH7g78sk9hPtJqVTC3NwcLBYLjhw5gpMnT2JxcRFWqxWJRELEP/j+bMJJ6nShUEAmkxGKJCOpPJO1WWNGxtWf2e12qTFMp9PS/Zksh90Cr4dZWQAIh8OwWCxYWVmRPZxGGoN3TqdTxC4IFu4nk0mhORUKBRQKBbzzzjtSAP3444/D7/cjEAiIo7G0tASXyyV8+o6ODvT09GB+fn5TFcJ73duDYrO1wd+xOSvngnrWq0Z7JpOBXq/H6uoqzp8/j0AggHPnzomQDxtrJhIJrK2t4a233kI4HMatW7ewsrIiTA3W5hoMBpw8eRIjIyMwmUwy52q1GgwGAwYGBuDxeHD+/Hl885vfRLFYxFNPPYVTp07h6tWrYlvG43HJfALN9ZyPCrgflEoljI2NwW634+jRo0J5DofDUgsDAD09PRgdHUU4HJY5qp7JQLMIUis86DnxwFaMaoSROqFOPq2ur7bgjEYOOeukUnBisxeEw+GQlDJwR5aLBaZ0DLYyYVpRvFSjfL9y+FwuF44dO4ZQKASn0ylRLB4kBI0Peqnk6yWTSUnPUyGh0WiIIU5NbNXAodNFvm6pVJL+FUzL0VBmqnMnoZ3g6nUze1OtVkVj22azCUc0mUzCaDRKIR4PGKqbrK+v48CBA7DZbOjt7YXJZGrKqOVyOTlQOTeq1dud2Ofm5rC+vo719XUxhDai4/H61bWy2TzdShRrJ6BGsPh/zn92ZiWNzOPxoFgsYnV1VTjcvEfSeRhhZaBBe5+t7me/rK39BLvdjgMHDsDpdIpRRn35XC6Ha9euSRSVDsf9qkztx/Hn/bAm79q1a2Kgkr5Hw5lZ2mw2i7m5OalJMxgMWFhYwNjYGObn5++K+O9HqOpzjPDTqFOzFlynhUJBAnxms1mMC3X/Vs9Y/j3XZCQSwfT0NCKRiHRh9nq9cLvdOHDgAEZGRtDd3d3kqOh0dzoUqx2tqZKl7idqMTivhfsaM9H1el3OLrUeYbdBeyUcDkOnu12bd+7cORw7dkxkzNUstPa6OB4s2Kect8PhwPDwMACgs7MTnZ2dsNlsUvBeLBZht9uRyWTw/vvvI5PJ4NatW1hbW5Mmu0CzFDDtpt1yktXAHB0x9TrU58bCdb1eL41r6XiqY1ssFkV+mgFiCvYUCgXk83mZ5yyWN5vNooDk9/thtVphs9kQDAZht9vR1dUFr9crjIxCoSCMFgY9aWSXSiUsLCyIc06HVl0X6vN9lMA1bTabpYFwZ2cnHA4Hent78eSTTzbR+QwGA9bX18Vu02Ivgk07Ei7lBapay/xiqoqHAyceD8l6vS4HCpuw0enQ6XRNE8zn84lyECkxU1NTiMVi0o15q96pdlBZTKPdpB8mtIthcHAQv/u7v4vOzk6srq5KU0TyavlacnHL5TKi0WhTxICcSy5GnU6HaDQqdAVtNoIKQsPDwzh06BCi0Sg++ugjWeSJRAKrq6tyaOy0DrrWUCV1TqfTifoEixCLxSL8fj+8Xq90ye3o6MBTTz0lHFuLxYIvfvGL+MxnPoNcLidZGtYTLCwsIBaLwefzSZTr1VdfbaoH4T2T0rZRB1dVJEH7+1a1QOpmvheRV+3ncHyB2448O6O/8MILcLvduHz5Mq5du4aBgQEcPHhQNrtGo4FAIACPx4OVlRUkk0mRX2YklLK+W6FJ7cco+14iFArhb/2tv4WDBw+ir69PoqF6vR6zs7P4F//iX+DKlStNxqe6Z6mc3EcNvGZSc9LpNP7oj/5IaCysoero6IDT6cSLL76II0eO4Nq1a3j33XfR09OD3/u930MgEMAbb7yB73znO0LP2e/jwV4UzEKEQiE89thjKJVK+Oijj8SYB26PTywWg9lsRk9PD5xOp/RLUp0K7jus6WBQQKfT4dKlS7h8+bIEV6xWK4aHh+H1evHyyy/jzJkzUvdHuhO/V6tVrK2t4ciRI1hbW8PExISoBJHmplUUUmmapLOy/pBc/L0A10sul8PFixfhcDjw8ssv4/d+7/fg8/mkHmiz+jg6H06nU/Y4OgM9PT1S9Mwi6MuXLyORSGB0dBRDQ0N455138O/+3b+TTvbMwqm1qABk7MvlsuzNOw3WPvE8UGnkZJDwfslIcTgcOHPmDILBIMbHx3Hjxo2mYCBpiszOm81mxONxABDHwGazST3Mc889h1KpJI0LAYhS5PPPPy+GNFXmjEYj1tbWcO3aNVy5ckVU58LhsHQLf/XVV4XKzzNatW+0jIUHheqQ7ub5TQfC4/Hgi1/8IoaGhmSvPHbsGHp7eyUwVa1W8cd//Mf43ve+1/K9tPRpYOsBwe2M2bYdDTU9xoXIaJpqUGgvUF2IdD4ymQxSqZRw2qnBXSqVhP9HGTVVv5opOyrW5HK5u7IR2z1U7od2sBfQRhiA2+Ody+WQTCalUVor46xYLMrhQ8lVOoIqF5ScxVYGrpoO12ZOeEDtJficVO4xKWEWi0X46yr9jZs3ixmZ2WAUhIWNdLyYIaF0YzweRywWQywWQzqdFq7jTvQq0FKntPUau42Nsnesg+K4FItFxONxrK+vw+12S3SKay+fz8NoNIoMIvcBreO/F5maRw1qVpAHvcvlgsfjQUdHhzS6MhqNSKfTcLlccDgcovSlpVj9KoBnCSmSOp1OJC25zt1uN9bW1uD3+xEOh7G4uIh6vS7d7CORCCKRSMss9X6E+gzVGi1SXU0mU5PDzj1cpX9wHvG7up+odGAGotQMNJ05yq/ySytIoCpZsYliR0cHDAaDBAp5HxQjYbSaUWV1r9vrwIKa5WEmvNFoSJ8QSsAzcMkeGK2grl0+G2YhGP1PpVJyjnR2dkqWnP1SnE6nSLU+LLlq7Weo84YZH7vd3hRc4/1rMz6qjajOUzpT3LcYnGRAmWdyR0eH2ImsAaXDS6eI9TDpdFqU5JgpYUZKtRlZk/CgBvN+gGrjcpw5vqyd5b1T4juXy0mN28NQd9x2Hw0adZSdJZWExgUXrXbz4M3lcjmsrKxIAZrZbMbnPvc5DA0NIRaL4f3330c8HpfGYX6/H729vfK3jUYDU1NTWF1dRTweF3WChYUFJJPJJsWkzcDrauUU3YvusRvQ8uUJGso2mw2Li4v41//6X4tmdKPRwK/92q/h6NGjsrGpB/SVK1fw//7f/0MikRAuvUrz2cjI1KLRaCAWi0mx8142L9Q6jqp8JSk8n/zkJ/H0009jZWUF/+N//A9UKpWmzbter2N0dBRf+9rXYLFY8N5772FhYQFnz57FCy+8IEXsiUQCP//5z3H16lU4nU5pAFav1+FyubC8vIxwOCzKZ/eaG5tFCLjBshcFHWc15clDayegdUa3cu2NRgO3bt3Cv/23/1ZULPL5PFZWVkTn/OrVq1KjYbFYEIvFsLa2BgASVdGmqLkxboRHwSjcKVDIwOFwIJ/PC/2Qa215eVmKKK1WK5LJJAYGBqDX6zE2NiZRcOJRzWRo0cp5osFAo4K0xddffx3JZBKRSESaQFqtVty6dUsyGY/CmKhUo0bjtjrU1atXpW8NqSHr6+swmUxS/B6NRhGNRtFoNGTNMdOodkNWedk8w5lNKJVKMBqNsgddvnwZ0WhUJHbZ0I+qQaTAUPb23LlzMJvNePXVV/Haa6/JfuNyufCbv/mbOHnyJF555RV897vfBXC7HkWv1zcxHijysdtQx4XZrps3b+L1118XVgXHpFar4bOf/Sy++tWvtqyXU4OnZHS8++67uHbtGtLptASk6HxMTk7CarXKeexyufCFL3xBshzvvvtu09lCpsVuBvS0xdHk66uBjy996Uv43Oc+h/Pnz+OP/uiPkM1mMTY2hsnJSRQKBVgsFpljBoNB6LapVArxeFzOa6PRiHg8DoPBAL/fD+BOU8p6vS4SyqTGWywWeR5+vx8ej0fsmdXVVUxOTmJ5eVno9W63Gy+99BLsdrs083vrrbfw4x//+C4Dnfe7U3Nur/eZaDSKP/uzP4PL5ZLzt7OzE5FIBPV6HcvLy8hkMrh06ZIEUbWZTvWatfbvve5lO/e6rYwGDR9ucj6fT7IQWvqINh3FG6Iknk6nE6P11KlTUly6sLCAtbU1zM/PIxaLYXR0FF1dXU20nIWFBdy4cQOlUknoL6w/uJ8H3SrKuteRVzVrod1UeHCk02m8/fbb0Ov1wt9+6qmnmiIGaqRqZWUFFy9elCZpD8JTJlVNq1aw29BeryqXzH8fPHgQL7zwAt566y387//9v5FOp0XRjNKLiUQCH//4x2G32zE2Nobx8XHhHzcatzXDI5EIJiYm8NFHH8HhcIj08vDwMCwWi8zdVte1lWtv9XtGBY1Go/STIHZyEwTQNL/uNb+5XqPRKN59992m67FarfB6vYjFYpicnEQmk2mKYDUaDYlkaiNe6vdHwfjbTXBcVJUzqvXFYjEp+Esmk/KaYrEIj8eDer2O2dnZu8bxV2lMtQcg9x3WAgK3G6dp18jKyor83aM0Htr7oDNls9nQ398Pm80mvXmYyQUgjTXpjLYKKqjZZ0beLRYLnE6nCLfodHeUzFZWVqQrM7MYanSUn8lo/6lTp+D1ejE+Pt50HxaLBadOncKLL76IyclJsQuYXabBT7tirxwNtVa0VrvdiXpmZgaZTAazs7NS21ipVDA8PNzkLPA9ADQ5cPl8HplMBhMTE/jlL38pcvEmk0mUq5jxZT2ky+WSovypqam7WAV7wRrg56lSulqFySNHjuCzn/0sarUavvGNb6BSqUhAyWazybzjOLndbvh8PqHg8n30er3Qj6lERUcDgGQtSqWSBBTJTlAVMBcWFiQjxGaPtVoNXq8XBw8ehN/vx6lTpxAKhbC4uHhPGtyjCPYPMZlM4vCXSiWYzWaUy2WMj48jkUhgZWVF1rxWNXaj/XGns4xbdjRUSkWjcVsZIxwOy8azUfMxbf8C8vz0+tvdXE0mE6LRKN566y3E43FMTk4ilUqhVqvB6XSKhGgwGITP5xMvOZFISDRkK1ri97qvVtH9vTykOHatJAK5+XODJC83FAphYWEB//k//+cm2VdKxl25cgWpVGrLWR51o9Hef6VSQT6f3xG60IOAUU29Xi9cZBbVzczMyKZEaVXWdCwsLOBb3/oWzGYzbt68iUgkInOuVCphZWUFmUwG8/PzTXUmapdr0rJo9NVqNSSTyW2pbGkL71hcz8NKWzOxU06d9r228wxpHNDBSyaTuHHjRpOUrzaowGghDRSVxrHdz/9VRqPRkEBNT08Pzp07B6/Xi+PHj8Nut2N8fBwXLlyQOddoNESmkbKuqjHCZ8Sf/VUY580ysY8SaHz39PQgEAggkUiI7GyxWJR6BvZIYoS4r68PJpNJetMYjUbY7XbU63XhrHNNer1enDlzBjabDQsLC4hEIrKPMqBVq9WwuLiI1dVVWK1WDA0NweVySSHuxYsXRZBgbm4OLpcLo6OjotoH3DHA0+k0fvazn2F6ehoffvgh6vW6KEqSQ87MwW6qFWqh7kONRgMHDx7Epz71KczMzGBmZga1Wg2jo6Pwer3IZDL43//7f6O7uxsf+9jHYLVa8Ytf/AKTk5NS+0dKNyVHFxcXJVvCehaKjbA4ul6/LSn+zjvvYGpqqqnOYa+h0+mkBoLyyY1GQ84rZlrGx8elb5Vag8jMIRktZKQwy2MymbC2tia0Y4PBgEOHDgldj4prV69exezsLFwuFwKBgFAgWURvtVqRTqexvLyMVCqF9fV1cfJY50PK2ptvvolKpYLz58/LdTErpdqLu+HIqWOz08+UY8/9gCIhFGLivk+aPGsl1WC0NqPTyj7YzAnZ7j1tK6NBT5eHHAtpVUNC6wmpahUApPjbYDAgEAjA7XZjfX0dP/nJT0Qus1KpIBQKwe12IxqN4vr16+jt7cXRo0cBQDjzvOmtGtKb3ddm/98LbKYqoRZpc/H39vbi8OHDuHTpEr7xjW/AarWit7dX1Fbi8XgTDWsr98TJy0NC/TvWyzxstIrwvPnmm3j77bebHCS1cFKn02FmZgZzc3NNDu7c3By+853vALjjALBwjApo7MBMmU3Snfr7+4VrutVxobEOQDY+HrJMv2uj0zsps/ygTgtpGfF4XGSQN3tPqshonYtHzQDcTdTrdcm6nT59Gl/72tfgcrng8/lQrVbxxhtv4Cc/+Yk4GhaLBYFAQKJW7NrLCD+prapy31+18X5U75fR3KNHj+L48eMYGxuT85AOBNUXadTZbDacPHkSgUBAmt/ZbDYx0khx4p7u9/vxyU9+Em63G3/yJ3+C69evi+HCmgxSqGhs+v1++P1+HD16FDabDb/4xS/wwx/+EIVCAel0Gt3d3fj1X/91uFwuybLw+lKpFL773e9K9qJWq8FkMsHn84nSISOtG3Uj3i3QuGLE/ktf+hLee+89fPvb30alUsHJkydx9OhRnD9/Hv/hP/wHnD59GidPnoTP58MPf/hDfP/734fH44Hf729Sh6JcPD8DgKgpaT8/m83i1Vdfvcso3eu6FdLcOjo6pG6WmSadTofXXnsNr732WpNtQNtOfXZ87ktLS3fdA6nyqVQKhUIB2WwWXV1dMm8ajQY++OAD/PznP8ehQ4fw9NNPiyMWiUTuEuxRv/Os4b6ZzWbx05/+FFNTU2K7sG5Dzc7xeu93zNT7U39OyvBGQjH3C9XJYDNrk8mERCIhtT/RaFT2Cl6LzWYTpTrV0VCDy5udF9pkwUav2wjbLgZvJX2mvSCtscS0rNZgYtE3B0Xlpnd0dKCrqwsApD/B4uKiaKEHg0EZWG6kKqxWKzwej9BitqqGpF7nXlKENgMnl5rqpUZ8PB4XRyuZTMJgMEgh/XbBZ9XqubIoUfWK9xJaao4KNaKupQyo/69Wq03OlOo8sRZCXWzcINQMCp1tLV2w1bpoNUZcC1qjW3VCWqlB7Qfw2Wuj5feKfOyX699v4Pzk3KF8MLXlK5WKNFBjbUK9frt/EDuDa/sX0BB4GAV/bTwYuH8wYstzj0YoAyCqrDGFA/x+P5aWlqRBLt/L7XaL4g+jv6Sa0BklTZRzkVkHnjnhcFgMZRosAwMDojIFADMzMzCbzVhdXZV7USmuvAc6FYxAm0wmuN1uoUHvNbg/LS4u4sKFC5KpLZVKCIfDsFqtWF9fR6FQQDQaxcWLF+FyucQWAe6cTaqk/Fb3PfWceVjg9bMugs9UPTu1AT7+jdY20WaKCBq5DM5RqIY9YeLxuMy1YrGIVCqF5eVlqQkiM4HzXmub0ekhZVyv10s/GvVMb3U27wZ1ig7sTkGv10vwnT1narWarHc+C9o1ql3C/6uiTQ8S/Lufc0XX2OJf8WFQs1vtLqgaS1ojXZuiafU1NDSEkZERZLNZTExMAAB+/dd/HY8//jjGxsbwzjvviA6zTqfDs88+i2PHjuH69et4/fXXpcGOavwMDAzg6aefRq1Ww3vvvScb4L3uUZXla1WEdV+D/IATmd4rJxFwu5iO/SI4LmxCtBGNbavX2uoeKR9HpYf7ef8HGTtuJBspc2wHrbz4Vl4656c2OkE+MZ2Oer0uaV1SAXid2nHSfo7akIjRQB50KrY7djuxebZ6j0fNeXgY63W7n0VFlWAwiIGBAVSrVcRiMWlaR5lIVUUFgNDtuGfRINjM0d0O9vvY7Wfcz9j19PTIc+NeXygUYDKZEAwGpaleKpWSsyoYDOIP/uAPcOzYMfzFX/wFvv3tb4sD4nA48IlPfAIHDhzABx98gLfffhs+nw/nzp2DxWLBhQsXMDc3h8OHD+OJJ55APp/H+Pg4crkcQqEQOjo6hEZDyo9er8dzzz2Hxx9/HJOTk3j11VelrwIAafpnNpvh8XgkC0pFqng8LtdmMpnQ2dkJr9eLcDiMhYUF+Zzt4kHnnd/vl/tlMS0ziNzLWU+n1+uxvr4u3dq1gh10Bh8G7mfe0W5Qz0Xte6lnGc9Fs9ncRI2v1Wobii+odhXfy263S+NCvgcVv6h+1mg0mhQkVRtAtTupTEXU63URvmkFNaLPubtdaf57zbmNbKnNgqYbwW6349d//ddx+vRpdHV14cCBA1heXsYf//EfixCSSpEE0LSX8ExoZTvtxTlx3/K2TLFycmlvoFWPAO3FMfKmRmkY9aCMIb/K5TKSyaRwOVk4ph6s/BxutHa7XVQQtnJf2nvcL9BeT6PRkCY56qawEz0sNotOa6VKN3rdZu9zv1AzEaoc7P18TisnSc1+qD8D7i6ebkXfauVAt8Jm16stnG51iD1M7LaDcb9zZ69pBjsNPvNisYj19XWJpqrBEy1NQJ3DajDnXnS2NvYvuK9ls9mmLr189gxiFItFmEwm2O32JgdTzXoRJpNJDGYA0iHZYrGgWq02qVTxDKZMJpsAFotFqSXjdXi9XqG85PN5rK2toVAowGw2i7wmi3lVKXIatZzbaq3JwwTlywmd7nato06nExukVCpJnxKVXbCT2Mg43U2ojgLPQToQrfb8Vmel9szT3ocaJCVI6+Nnq2Bdkvp+m52FtE8oTqQ+o40M+9228XbyOep0t0VYVNlziiqp9q9aZ0XBAVWCeaeva8vXv92MBqMThw4dwtmzZ5HP5/HWW2+JAgEjwNzYmLbhhsYJp6Zw2IyPTZoA4MiRI+ju7pZMBhd5tVqFx+MRJ4ITkhsdjTWPxyMRooWFBakn2co9tqKGPQid6kEndCsDf6+pETw4yMds9dlqMyjKHau43wipTnebSscDjI7n8vJy04HMzQbY2fHZiiGr7TGiOtKbgc+WhV06nU6ob52dnRgaGoJOp8P7779/X9e83ftQX6v2dtjP0BbYq3gUovKcO5zbpF/QaajX6xJ4YUBBe5BupFj3IHgUxm6/4n7G7tChQwDuRI/z+TySySSA20wCvV4v9XoHDhzA888/D5PJhEgkIvWNs7Oz8tlWqxVnzpxBT08PJiYmcP36dZjNZvj9fjFIVHpHpVJBLBZDtVqF2+2G3W6H1+tFf38/isUixsfHkclkcO7cOZw8eRKLi4v44IMPkM1mhUr63HPP4emnn8bS0hLeeOONpnOXkuE8r2u1GkKhEJxOJ9LptGQSHkZGY6P3ajQaEvBRg1v7NahxP9fFTANrhFgTpL6X9t+qMwI0OxZqUET9WzWApjIKtjKeagCv1ZlEVoB6jWQb0Mnlmay+p/p9u3vng8y57TqURqMRQ0NDCIVCkgnK5XK4deuWNCgsl8s4d+4cvva1ryGVSuGP//iPMT09jY6ODul9FYvFdtw53pWMBjdBdlxOJpO4ePGiOBqchHQ0VC4pGw5pJwqb9DG7AQBTU1NYWlqCx+NBMBiUtGW5XMbKygpSqRSCwSCGhoZgtVqbisMpoTY/P49Go9HkGd8LraIU2gm511CzQg8rwq1qsBNaw5XpVBZb7VT6WPXm+b1QKCASibR0NHb6ENjK+2lpLFuFug60mROXy4X+/v4difapEaetOhqPitH4qGc0OHdUnnor54lzWz1w+ZqHzfNu48HBaD8DDmrBK+cFn73P58Pjjz8uqnutFItqtRrW1tZQKpWEA18qlaQPx+DgIAKBAMLhMGZnZ5tqfWq1GtLpNJxOJ3p6epDP56X3QyKREBl60jz5t0NDQ/jEJz6BK1eu4I033pA6okbjdifjUCgk/SUqlQpyuVxTXcN+gDaouFsSs/tl3+Lns20BAFEsAlpLknPPUX9Gg14dv1YZBL6O82IrTgY/c6PXU6TIYDCI7Un7g3bTRvWRD2P8t/uZtVoN09PTmJmZaXouHG8GNXt7e/H5z38e6+vr+MEPfgDgdl2V1+sFAOnO3gq7OR+33bCPFxIOh/HOO++gUCgglUo1vZbKUgCa6FEb0V1Uz5afo0bNudApFccJxU2TvM5W3u5WI7Kqx9zq9fvB6FLv5WFvTq2ugbQOUtp2EixGNJlMouGuTcVqn7U2arARNUqFxWKRhkHb6Tui0p60G6LKA1V/p40SsaiL95BKpTAzM7MjRWXbnS+PQiaDaHVg7If1+iDQ3hOpMdq9ciN6QxuPHj72sY+hVqtJMzIqCVJFR6UsGY1GfPjhh2g0GggGg8JRV/sMsI4yFouhUChIIIbc+kwmg3K5jHw+D7PZjI6ODjz//PNwuVw4f/48JiYmkEwmMTk52aR85ff7pZYIuB2hHhwchM1mkwaKlAlXAxYsqKZMOkGDiRm7h429uob9cK/Anb2S+wvPIfV3qhiMNoBIiVo1w0rZVapLqXsUzxV1H2slB9tqfNR9D2iWkVVr17T3tlkm6lE4K3jfWptBDQ4AtwP0f/Inf4JMJoNIJAIA0reESmKbfcZuYduOBh/W7OwsFhcXZWKqaCXptZlOdquIXKlUkggfB4wDwUmfz+dF+QFo7jCpFpVtZQBVHlurCblfJuN+Nv5qtZo4mDt1nVxclABVf9aKp66qLRBaekkrB4nvYbPZYLPZpFfBVkHqi+pUq/OVxePcSBnNIagCoyIajbZsSHa/2M5G8igZr60K7vfLer1ftIpOq9k7YPPDv41HD1//+tdRLBbxne98B4uLi3A6nejo6EC5XJZ+GkNDQxgYGMDKygp+8pOfwGKx4FOf+hQGBgbQ1dWFzs5OzM/P4+c//zlisRiWl5eRTqfRaDQk28qscywWk14sVqsVw8PD+If/8B9iYGAA/+yf/TOMj48jGo2KrDf3uFAohNHRUaHXGAwGHDt2DF1dXZiYmMD7778vDgz3XRbnUmCFgUF+7VWzvq3gUdn3dhqsxyHU52M2m6WOR2sj2Ww2uN1uOf+pkOR0OhGJRIQ+r7JZtI4mn7+qqKZCa2SrDXupNsXzWlXNok3Xan/cL/Ntq2g1L7WB5ytXrmB8fFyCvo3G7XpeOhkPy368b06GqkKwkee5HWxk/N3L4NEqIdzPNTxqE24/Y7c26a0Yvvf72eompm6u2+VR7jTalJgHQ3tdt/EogVFhBkRIMSE9goYTOfWU3WaWgg4DMxZayW5CDRqqxofBYIDNZoPD4WhqbEZKKKPHfG81mEMHhgETbSBFDQ5txBh42PvtX3WoGYlW2Ozn2i/tvNUyYrbz/ptBfe97zZ9fpYz3RmgVkNps3e0VtlwM3kYbbbTRRhtttNFGG220sVXsXEeRNtpoo4022mijjTbaaKON/x9tR6ONNtpoo4022mijjTba2HG0HY022mijjTbaaKONNtpoY8fRdjTaaKONNtpoo4022mijjR1H29Foo4022mijjTbaaKONNnYcbUejjTbaaKONNtpoo4022thxtB2NNtpoo4022mijjTbaaGPH0XY02mijjTbaaKONNtpoo40dR9vRaKONNtpoo4022mijjTZ2HP8f6oVyd8HnHjwAAAAASUVORK5CYII=",
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"import torch\n",
"import torchvision\n",
"import torchvision.transforms as transforms\n",
"import torch.nn as nn\n",
"import torch.optim as optim\n",
"from torch.autograd import Variable\n",
"import matplotlib.pyplot as plt\n",
"\n",
"# Hyperparameters\n",
"batch_size = 64\n",
"learning_rate = 0.0002\n",
"epochs = 15\n",
"\n",
"# MNIST Dataset\n",
"transform = transforms.Compose([\n",
" transforms.ToTensor(),\n",
" transforms.Normalize(mean=(0.5,), std=(0.5,))\n",
"])\n",
"\n",
"train_dataset = torchvision.datasets.MNIST(root='./data', train=True, transform=transform, download=True)\n",
"train_loader = torch.utils.data.DataLoader(dataset=train_dataset, batch_size=batch_size, shuffle=True)\n",
"\n",
"# Discriminator\n",
"class Discriminator(nn.Module):\n",
" def __init__(self):\n",
" super(Discriminator, self).__init__()\n",
" self.fc = nn.Sequential(\n",
" nn.Linear(784, 256),\n",
" nn.LeakyReLU(0.2),\n",
" nn.Linear(256, 256),\n",
" nn.LeakyReLU(0.2),\n",
" nn.Linear(256, 1),\n",
" nn.Sigmoid()\n",
" )\n",
"\n",
" def forward(self, x):\n",
" x = x.view(x.size(0), -1)\n",
" return self.fc(x)\n",
"\n",
"# Generator\n",
"class Generator(nn.Module):\n",
" def __init__(self):\n",
" super(Generator, self).__init__()\n",
" self.fc = nn.Sequential(\n",
" nn.Linear(100, 256),\n",
" nn.LeakyReLU(0.2),\n",
" nn.BatchNorm1d(256),\n",
" nn.Linear(256, 256),\n",
" nn.LeakyReLU(0.2),\n",
" nn.BatchNorm1d(256),\n",
" nn.Linear(256, 784),\n",
" nn.Tanh()\n",
" )\n",
"\n",
" def forward(self, x):\n",
" return self.fc(x)\n",
"\n",
"discriminator = Discriminator()\n",
"generator = Generator()\n",
"\n",
"# Loss and Optimizer\n",
"criterion = nn.BCELoss()\n",
"d_optimizer = optim.Adam(discriminator.parameters(), lr=learning_rate)\n",
"g_optimizer = optim.Adam(generator.parameters(), lr=learning_rate)\n",
"\n",
"# Training\n",
"for epoch in range(epochs):\n",
" for i, (images, _) in enumerate(train_loader):\n",
" current_batch_size = images.size(0)\n",
"\n",
" # Train Discriminator\n",
" real_images = Variable(images.view(current_batch_size, -1))\n",
" real_labels = Variable(torch.ones(current_batch_size, 1))\n",
" fake_labels = Variable(torch.zeros(current_batch_size, 1))\n",
"\n",
" # Real images loss\n",
" outputs = discriminator(real_images)\n",
" d_loss_real = criterion(outputs, real_labels)\n",
"\n",
" # Fake images loss\n",
" z = Variable(torch.randn(current_batch_size, 100))\n",
" fake_images = generator(z)\n",
" outputs = discriminator(fake_images)\n",
" d_loss_fake = criterion(outputs, fake_labels)\n",
"\n",
" # Backprop and optimize\n",
" d_loss = d_loss_real + d_loss_fake\n",
" d_optimizer.zero_grad()\n",
" g_optimizer.zero_grad()\n",
" d_loss.backward()\n",
" d_optimizer.step()\n",
"\n",
" # Train Generator\n",
" z = Variable(torch.randn(current_batch_size, 100))\n",
" fake_images = generator(z)\n",
" outputs = discriminator(fake_images)\n",
" g_loss = criterion(outputs, real_labels)\n",
"\n",
" # Backprop and optimize\n",
" d_optimizer.zero_grad()\n",
" g_optimizer.zero_grad()\n",
" g_loss.backward()\n",
" g_optimizer.step()\n",
"\n",
" if (i + 1) % 100 == 0:\n",
" print(f'Epoch [{epoch}/{epochs}], Step [{i+1}/{len(train_loader)}], d_loss: {d_loss.item():.4f}, g_loss: {g_loss.item():.4f}')\n",
"\n",
"# Generate and show images\n",
"def show_generated_images(generator, num_images=10):\n",
" z = torch.randn(num_images, 100)\n",
" fake_images = generator(z)\n",
" fake_images = fake_images.view(fake_images.size(0), 28, 28)\n",
" fake_images = (fake_images + 1) / 2 # Rescale to [0, 1]\n",
"\n",
" fig, axs = plt.subplots(1, num_images, figsize=(num_images, 1))\n",
" for i in range(num_images):\n",
" axs[i].imshow(fake_images[i].detach().numpy(), cmap='gray')\n",
" axs[i].axis('off')\n",
"\n",
" plt.show()\n",
"\n",
"show_generated_images(generator)\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Beyond VAEs and GANs\n",
"\n",
"Generative AI methods have been advancing rapidly. Note that current state of the art methods for generating images (or videos) from text prompts are not VAEs or GANs (DALL-E 1 was a variant of a VAE, but DALL-E 2 is not). More recent methods use **diffusion models**, which start with a pattern of random noise and then gradually transform this pattern into a coherent image. This transformation occurs in steps, each slightly reducing the randomness and shaping the noise into an image that corresponds to a given text input. For more on advanced generative AI techniques, I recommend taking COMPSCI 670, Computer Vision."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Large Language Models (LLMs)\n",
"\n",
"*Large language models* (LLMs) are parametric models applied to text (or audio). Models like GPT-4 are based on *transformers*, a type of artificial neural network architecture. \n",
"\n",
"ChatGPT using GPT-4 claims that it has 175 billion tunable parameters. The wikipedia page suggests 1 trillion to 1.76 trillion parameters. It was trained on 13 trillion tokens, or roughly 10 trillion words (roughly 50 terabytes of data).\n",
"\n",
"Perhaps surprisingly, GPT-4 uses supervised learning: given the tokens (words and parts of words) seen so far, it attempts to predict what the next word will be. Training such a large network on so much data was estimated to have cost roughly $60-$100 million.\n",
"\n",
"More specifically, the model takes as input the most recent \"tokens\" (parts of words), up to 32,768 tokens, and predicts what the next token will be. After training using supervised learning, a form of reinforcement learning from human feedback (RLHF) was used to finetune the model to produce more desirable answers to prompts.\n",
"\n",
"While there are some properties that are beyond the scope of this course (e.g., the details of the transformer architecture and the use of a mixture of experts), the core technology underlying GPT-4 and hence ChatGPT is simply a large parametric model trained using gradient descent on a large amount of data."
]
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.11.7"
}
},
"nbformat": 4,
"nbformat_minor": 2
}